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

Annotations already declare it is a non-readonly, non-idempotent, non-destructive mutation. The description adds the useful partial-update contract ('пропущенные настройки сохраняет'), clarifying that omitted settings are preserved — genuinely beyond the annotations. It still omits auth requirements and the effect on unspecified settings during the merge.

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

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

Two tight sentences with zero waste, and the scope (what it changes) is front-loaded ahead of the partial-update behavior.

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 exists, so return values need not be described. However, for a mutation with 8 params at 0% schema coverage, the description leaves three settings unexplained and gives no usage context, so it is only partially sufficient.

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

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

Schema coverage is 0% across 8 params, so the description must compensate, and it names five of them (язык=locale, тема=mode, акцент=accent, плотность=density, анимации=motion). It leaves custom_hue, glass_intensity, and sidebar_collapsed entirely undocumented and gives no format/syntax detail beyond the schema enums.

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 (меняет/changes) plus the resource (panel appearance) and enumerates which settings are affected (language, theme, accent, density, animations), so an agent knows what the tool does. It does not, however, differentiate itself from the sibling account_update, which plausibly overlaps.

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, and no routing away from or toward alternatives such as account_update or account_security. The agent must infer that this touches only visual settings.

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

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

Annotations already mark it destructive, non-idempotent, and open-world, but the description adds critical context: passwords never enter MCP arguments or responses, and existing browser sessions are terminated. This exceeds what the annotations alone convey.

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

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

Three sentences, front-loaded with the core action, then security handling, then the session-termination side effect. No wasted words; every sentence adds useful information.

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

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

For a destructive, security-sensitive tool with a rich schema and annotations but no output schema, the description covers purpose, prerequisite, security constraints, and a key side effect (session termination). It does not describe error behavior or return format, but those gaps are minor given the schema and annotation coverage.

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 single parameter is fully documented in the schema. The description adds meaning beyond the schema by explaining why the file exists (human-created outside MCP) and that passwords never appear in arguments or response, reinforcing secure parameter handling.

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 ('Меняет пароль') and specifies the exact mechanism (local JSON file created outside MCP). This distinguishes it from siblings like account_update or account_security, which handle different account aspects.

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

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

It provides clear context for use: the password file must be created by a human outside MCP, and passwords must not be passed as arguments or via MCP forms. No alternative tools are named, but the when-not condition is explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so most of the safety profile is covered. The description usefully adds an auth constraint beyond that: the browser-session requirement and the integration-token limitation. It does not describe what the returned link targets or how it behaves.

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

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

Two compact sentences, front-loaded with the resource and followed by the access constraint; no filler. The phrasing is slightly indirect ('Ссылка на управление') rather than stating the action, but nothing is wasted.

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

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

For a no-output-schema, single-optional-parameter pointer tool, the definition covers what it returns (a link), the auth constraint, and the capability boundary. Nothing critical is missing, though it does not confirm whether the section parameter alters the target.

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

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

Schema coverage is 0% and the single 'section' parameter has an enum (security | integrations) with no descriptions. The description names topics that map obliquely onto those enum values (2FA/recovery codes vs. integration tokens), so an agent can guess, but it never explains the parameter or its values explicitly.

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 what the tool provides (a link to managing 2FA, recovery codes and integration tokens), which is a specific resource rather than a tautology of the name. The weak verb ('Ссылка на' = 'Link to') leaves a little ambiguity about whether it performs actions or merely returns a pointer, but the scope is inferable.

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

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

It gives a clear precondition (these operations require a browser session) and an explicit limitation (an integration token cannot issue new tokens or change 2FA), which tells the agent when this tool is usable. There is no routing to a specific alternative among the many account/session siblings, so it stops short of a 5.

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

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

Beyond the annotations (readOnly=false, idempotent=false, destructive=false, openWorld=true) the description discloses two non-obvious traits: patch semantics (unspecified fields are untouched) and an onboarding gate (all name/birth-date fields required before the API otherwise works). It omits that passing null erases a value and says nothing about the response or side effects of the Telegram/MAX notification.

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

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

Three sentences, front-loaded with the action and affected fields, with the two behavioral notes packed in tightly. Dense but each clause carries information; the parenthetical about the scenario node is somewhat tangential to 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 a mutation tool with no output schema and rich annotations, the definition covers mutability model and a critical precondition. Remaining gaps (null-erase behavior, response shape, side effects of outward notifications) are partly covered by the schema and are relatively minor.

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

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

Schema description coverage is 100% and the schema itself documents every field, including the important null-erases semantics for max_id/telegram_id/avatar_url. The description adds only the high-level field list and the partial-update rule, 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?

States a specific verb (меняет) and resource (данные аккаунта) and enumerates the exact mutable fields (ФИО, дата рождения, телефон, часовой пояс, Telegram/MAX id), which clearly separates it from account_security, account_appearance and account_password.

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

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

Gives concrete usage guidance: pass only the fields to change, the rest stay as-is, and it names a second use case (прохождение шага знакомства). It does not point to a sibling for the cases this tool does not cover, so it stops short of a 5.

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

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

Beyond the annotations, the description reveals important behavior: deletion destroys saved keys, deletion is blocked while the connection is still referenced, and the agent must first detach it from bots, knowledge bases, and AI Reply nodes. This is rich, non-obvious context that annotations alone do not provide.

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

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

The description is only two sentences: the first front-loads the core destructive action, and the second compactly lists the necessary dependency-clearing steps. Every sentence earns its place, and there is no filler.

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

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

For a destructive delete tool with no output schema, the description covers the effect, the sensitive-data consequence, the blocking condition, and the exact steps to unblock it. This is sufficient for an agent to invoke the tool correctly and avoid failed calls.

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. The description does not add significant new direct meaning for the provider or case parameters, though it does mention provider_id in flows_save as part of the unblocking workflow. 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 starts with a specific verb and resource: 'Удаляет подключение вместе с сохранёнными ключами' — it clearly states what is deleted and that saved keys are also removed. This distinguishes it from sibling AI tools like ai_save, ai_list, and ai_test.

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

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

The description explicitly explains when deletion is blocked ('Пока сервис используют боты, панель удалить его не даст') and provides precise removal steps using sibling tools with parameter values: bots_save ai_provider=null, knowledge_save provider=null, and flows_save. This gives the agent clear conditions and alternatives.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, idempotentHint=true). The description adds meaningful behavioral context by disclosing that keys are masked and only the last characters are shown, which is beyond what annotations provide.

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

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

Two well-formed sentences, purpose front-loaded, with zero wasted words. The key-masking note is placed as a secondary sentence, keeping the core purpose clear.

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 tool with no output schema, the description adequately covers what is returned (services, models, bot usage counts, masked keys). It does not explain how the provider parameter changes output to a full card, but that detail is present in the schema.

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

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

Schema description coverage is 100%, so both the case and provider parameters are already documented in the schema. The description adds no additional parameter meaning, which is the baseline when the schema fully covers them.

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

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

States a clear list operation over AI service connections, including the models and bot counts returned. It is specific and distinguishable from ai_save/ai_delete/ai_test, but does not explicitly name a sibling to differentiate from, which keeps it at 4 rather than 5.

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

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

The description states what the tool returns but gives no when-to-use guidance, no conditions or alternatives, and no exclusions. An agent can infer it is for viewing connected AI services, but no explicit usage context 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?

Annotations cover safety (destructive=false, idempotent=false) and the description adds genuinely non-obvious behavior: on update, passed keys are merged over existing ones and cannot be erased with an empty string, only overwritten. This merge/no-erase constraint is exactly the kind of context structured fields cannot carry.

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

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

Front-loads the provider create/update distinction, then a compact per-provider key list, then the merge caveat. Dense but every clause earns its place; the enumeration is long but necessary given the credentials gap.

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 13-param, no-required-param, no-output-schema mutation tool, this covers the two hardest parts (create vs update, and credentials per kind) plus a merge gotcha. Largely complete; it does not mention default case resolution or the response shape, though those are minor 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 coverage is 100%, but the credentials object is deliberately generic in the schema ('composition depends on the service — see tool description'), and the description supplies that per-provider key map (gigachat authorization_key/scope, yandexgpt api_key/folder_id, custom base_url, etc.). That is real added meaning beyond the schema, though the create-vs-update 'provider' semantics could be tied more tightly to the parameter.

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

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

States a specific verb+resource (podklyuchit/nastroit ИИ-сервис) and precisely distinguishes the two modes: create without provider, update with it. An agent can tell it apart from siblings ai_list, ai_delete, ai_test without opening any schema.

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

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

Explicitly explains the provider parameter's role in selecting create-vs-update, which is the key decision. However it does not name when to reach for ai_test or ai_list instead, so it stops short of full alternative routing.

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

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

Beyond annotations (readOnlyHint=false, idempotentHint=false), the description discloses that this is a real request consuming limits and potentially costing money. It also mentions it shows 'reason for refusal,' indicating potential failures. These are valuable behavioral traits not captured in annotations.

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

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

The description is two sentences long, front-loaded with the action and outcome, and the cost warning is a necessary caveat. Every sentence earns its place with no fluff or repetition.

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

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

Given the simplicity of the tool (3 parameters, no nested objects, no output schema) and the strong annotations, the description covers the essential aspects: what it does, what it returns (response or error reason), and the cost/limit implications. It is complete for an agent to select and invoke it correctly.

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

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

Schema description coverage is 100%, and each parameter (case, prompt, provider) already has a description. The tool description adds no additional parameter-level semantics, so it reaches the baseline but does not elevate it. It does not repeat or contradict schema information.

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

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

The description states a specific verb+resource: 'Sends a test replica and shows the model's response or reason for refusal.' This clearly distinguishes it from sibling tools like ai_list or ai_save, as it is about testing an AI service rather than managing configurations or listing services.

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

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

The description gives clear context: it sends a real request to the service and warns that it consumes limits and may cost money. This implies caution and informs when to use (testing a service) but does not explicitly name alternatives or exclusions. The cost warning is a useful usage guideline, though it could be more explicit about comparing to ai_list/ai_save.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so safety is covered structurally. The description adds real context beyond that: the filter values must match keys returned in a prior response and may include deleted connections, which warns the agent about value provenance. It still omits anything about auth needs, rate limits, or result size.

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

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

Two tight sentences, front-loaded with what the report contains and followed by the critical value-provenance constraint. No filler, though the second clause is dense and slightly cryptic without the prior-response context.

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

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

For a read-only report with no output schema, the description usefully enumerates the report's sections (totals, comparison, days, breakdowns), which partially stands in for a return-shape spec. But with 5 of 6 parameters undocumented in the schema and only a partial description of the filter values, the definition leaves the agent short on how 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 only 17% (only 'case' is documented), so the description must compensate. It partially does by explaining that provider, bot, kind and model are exact keys from the previous response's choices (including deleted connections), giving their valid domain. The 'days' parameter and the schema's case semantics remain unexplained by the description.

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

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

The description states a specific deliverable: a full usage report ('Полный отчёт расхода') with totals, comparison, per-day data and breakdowns. This is clearly a reporting/read tool and is easily distinguished from the ai_list/ai_save/ai_delete/ai_test siblings. It does not, however, explicitly name or contrast with a sibling.

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

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

There is no explicit statement of when to use this tool versus alternatives such as ai_list or ai_test. The only usage-shaped hint is that provider/bot/kind/model must be exact keys from a previous response, which is a data-sourcing note rather than selection guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile needs no restating. The description contributes one genuinely useful behavioral detail beyond them: results include departed participants. It says nothing about result shape, ordering or pagination, so it is only a modest addition.

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

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

A single compact sentence with the key qualifiers front-loaded and no filler. It is arguably too terse rather than padded, so it does not lose points for verbosity.

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

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

For a one-optional-parameter, read-only aggregation tool with no output schema, the agent still lacks any indication of the returned structure (e.g., a list of event types vs. authors with counts). The phrase 'with number of records' hints at it but does not fully compensate for the absent output 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 sole 'case' parameter is fully documented in the schema, including the default-resolution behaviour. The description adds no parameter-level semantics 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 names the resource (event types and authors) and adds qualifiers (record counts, includes departed participants), which distinguishes this enumeration/filter tool from the sibling audit_list that returns the journal entries themselves. It does not name the sibling explicitly, but the scope is clear from the text.

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 call this versus audit_list or any other sibling, and no mention of prerequisites or ordering (e.g., call this first to discover valid filter values). Usage must be inferred from the noun phrase alone.

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

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

With annotations already declaring readOnly, idempotent, non-destructive, and openWorld behavior, the description adds meaningful context beyond annotations: it lists the types of actions recorded, notes that token-performed actions identify the token, states that reads are not logged, and names the required audit.view permission.

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 reasonably concise and front-loads the main purpose. There is some redundancy between 'who changed what' and 'answers who did this', but every sentence still contributes useful scope or permission information.

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

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

Given that all parameters are documented in the schema and annotations cover the safety profile, the description is fairly complete: it includes content scope, token-action behavior, read exclusion, and the required permission. It does not need to explain return values because no output schema exists, though more detail on pagination or filtering could help.

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 five parameters are already documented in the input schema. The description does not add syntax, defaults, or filtering semantics beyond what the schema provides, making the baseline score 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 states a specific purpose: an audit journal showing who changed what in a case, including edits, enables/disables, deletions, and permission grants. It is clear enough to distinguish from generic list tools, but it does not explicitly contrast itself with the sibling audit_filters tool.

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

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

It gives useful context that the tool answers 'who did this' and that read operations are not logged, plus a required permission (audit.view). However, it does not state when to use this tool versus alternatives such as audit_filters, nor does it give explicit exclusions.

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

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

Annotations only declare the coarse profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true). The description adds real behavioral nuance the annotations cannot convey: additive-by-default semantics, the opt-in deletion path, and the deferred-sync timing. It stops short of noting auth/permission requirements, so not a 5.

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

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

Three tightly packed sentences with no filler; the core reconciliation behavior is front-loaded, followed by the two flags that modify it. Every clause carries distinct information.

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

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

For a 5-param non-mutating-looking yet actually write tool with no output schema and full schema coverage, the description covers the divergent default behaviors an agent would otherwise get wrong. Return-value behavior is unstated, but with no output schema that gap is minor.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds behavioral meaning to two key params beyond their schema text — remove_missing governs preservation of unlisted commands and sync governs when the platform is actually updated. The commands array is correctly framed as the complete desired menu in order.

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

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

States a precise verb and resource ('приводит меню команд бота к переданному списку') and immediately decomposes it into add/update/reorder semantics. An agent can distinguish this reconciliation tool from siblings like bots_save or bots_detach without opening a schema.

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

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

Gives concrete conditions: commands absent from the list are preserved unless remove_missing=true, and the platform menu only refreshes with sync=true or a bot restart. It does not name an alternative sibling, but the when-to-use context is explicit rather than implied.

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

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

Annotations already state readOnlyHint=false and destructiveHint=false, so the agent knows this mutates bot state. The description adds useful behavioral nuance: startup automatically syncs the menu, while a separate sync is required after editing commands on a live bot. This goes beyond what structured data provides.

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

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

Two compact sentences: the first enumerates the actions, the second explains the only important conditional nuance. There is no filler, no restating of the schema, and the key context is front-loaded.

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

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

For a simple three-parameter tool with no output schema, this description covers the main actions and the sync nuance well. A brief note on the effect of stop/restart on a running bot would add completeness, but the current text is sufficient for correct selection and invocation.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description reinforces the meaning of the action enum by explaining the sync_commands edge case, but it does not add extra detail about the bot or case parameters. 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 starts with a specific set of actions and resource: 'Запускает, останавливает или перезапускает бота, а также отправляет меню команд'. This clearly distinguishes bots_control from sibling tools like bots_save or bots_journal by naming the runtime-control responsibility.

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

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

The description gives explicit guidance about when the sync_commands action is needed: after editing commands on an already running bot, because startup already performs synchronization. It does not name sibling alternatives, but the provided context is unambiguous for the listed actions.

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

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

Annotations already indicate destructiveHint=true, but the description adds specific consequences: deletion of commands, variables, dialogues, and irreversibility. This goes beyond the annotation, giving the agent a full picture of the tool's impact.

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

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

Three short sentences: the first states the core action, the second describes consequences, the third gives an alternative. Every sentence adds value and the description is front-loaded, making it easy to parse.

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 no output schema, the description fully explains the destructive behavior, scope, and irreversibility. It also provides a contrast with the non-destructive alternative, making the tool's usage context 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% with clear descriptions for bot, case, and confirm_name. The tool description does not add additional parameter-level details, so the baseline score of 3 applies.

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

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

The description clearly states the tool removes the bot from the case along with commands, variables, dialogues, and correspondence, and that restoration is impossible. This distinguishes it from sibling tools like bots_save (used for temporary disablement).

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

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

Explicitly provides an alternative for temporary disablement: 'use bots_save enabled=false.' This tells when not to use this tool and directs to the correct sibling, fulfilling the usage guideline requirement.

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

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

Annotations already declare destructiveHint=true and idempotent=false, but the description meaningfully adds that an exact-name confirmation is required, that flows/dialogs/broadcasts/journal are retained by default under an archive entry, and that flows can be handed off to another bot. That is real behavioral context beyond the annotations.

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

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

Three short sentences, front-loaded with the action and confirmation requirement, then defaults, then the optional transfer. No filler, though it could more tightly tie the retention sentence to the keep_* switches.

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, 8-parameter tool with no output schema, the description covers the confirmation requirement, default retention, and the transfer option. Minor gaps remain around the 'case' scoping and error behavior, but annotations plus full schema coverage carry the rest.

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 8 parameters including their defaults. The description only reinforces confirm_name and flows_to semantics without adding format or edge-case detail, 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+resource ('Отключает бота') and adds the distinguishing constraint that data is preserved under an archive record rather than purged. This implicitly separates it from siblings like bots_delete or bots_save, though no sibling is named explicitly.

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

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

Usage is only implied: the default-retention semantics hint that this is the non-destructive alternative to deleting a bot, but there is no explicit 'use this when... instead of...' statement and no prerequisites (permissions, irreversible effects) called out.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds valuable behavioral context beyond annotations: secret variable values are hidden. This is a meaningful disclosure about response content that annotations do not cover.

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

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

The description is two concise sentences. The first sentence front-loads the core purpose with a colon list of contents; the second adds a crucial detail about secrets. No wasted words or redundant information.

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

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

The description covers what the tool returns, including the masking of secret variables, which is important given there is no output schema. With strong annotations and 100% parameter schema coverage, it is nearly complete, though it does not explicitly address error cases or access restrictions.

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 'bot' and 'case' parameters have descriptive text. The tool description itself adds no extra parameter semantics, so the baseline score of 3 applies.

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

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

The description clearly states the tool returns the full bot object ('Бот целиком') and enumerates its contents: settings, command menu, content variables, and scenario list. This distinguishes it from sibling tools like bots_list (list only) and bots_save (modify). The implicit verb is evident from the tool name and title.

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

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

The description implies this is the comprehensive single-bot retrieval tool, but it does not explicitly state when to use it versus alternatives such as bots_list or bots_control. No exclusions or alternative tool names are mentioned, so usage guidance remains implicit rather than explicit.

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

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

Annotations already signal readOnly, idempotent, non-destructive behavior. The description adds meaningful behavioral context: entries are returned newest-first, the log is recent history rather than an archive because the panel removes old entries, and the response ends with a summary of encountered kinds and counts. This goes beyond the structured annotations without contradicting them.

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

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

Every sentence adds distinct value: scope of entries, differentiation from audit_list, ordering and filtering, response summary, and retention behavior. The text is dense but not bloated, and the most important information is front-loaded.

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

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

There is no output schema, but the description partially compensates by explaining ordering, filtering, the kind summary at the end, and the non-archival nature of the log. A more explicit list of per-entry fields would make it fully complete, but the provided context is sufficient for an agent to call the tool and interpret the high-level 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%, so the schema already documents all six parameters. The description mentions the kind and level filters, particularly level=error, but does not add new semantic detail 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?

Description opens with a concrete statement of what the tool returns: bot actions such as starts/stops, incoming updates, model responses, script errors, and platform refusals. It also explicitly contrasts this with audit_list, making the resource and scope unmistakable and distinguishing it from a sibling tool.

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

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

The description explicitly names audit_list as the log of human actions and states that this journal answers 'why the bot is silent', giving a clear selection condition. It also explains how to narrow results by kind and level, which directly supports correct invocation.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds context about the output contents (status, operation mode, dialogue counts, unread), which is useful behavioral information beyond the annotations. No contradictions.

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

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

The description is a single, compact sentence that front-loads the resource and purpose. It avoids unnecessary words while conveying the key output fields.

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 one optional parameter, the description provides sufficient context: what is listed and what information is included. Annotations cover safety, and schema covers parameters. The lack of output schema is mitigated by the description's field enumeration.

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

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

The single parameter 'case' is fully described in the schema (100% coverage), including default behavior when omitted. The tool description itself does not add parameter details, so it relies on the schema, appropriate for 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 clearly identifies the tool as listing bots for a case ('Боты дела'), with a specific verb ('список') and resource ('боты'). It also lists the returned aspects (status, mode, dialog counts, unread), distinguishing it from sibling tools like bots_get by its list-focused 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 implies usage for retrieving bots of a case, but it does not explicitly state when to use this tool versus alternatives (e.g., bots_get). No exclusions or conditions are mentioned, so it falls short of clear guidance.

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

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

Beyond the annotations, the description adds crucial behavioral context: the token grants full control over the bot, and the tool should be used only on explicit user request. This meaningfully expands on destructiveHint=true and explains why the operation is sensitive.

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

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

Two sentences, zero filler. The first sentence states the primary function; the second delivers essential security guidance. The most important operational caution is placed up front.

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

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

For a two-parameter tool with no output schema, the description covers the action, the sensitive nature of the result, and the required user-consent condition. It is complete enough for safe invocation, though it does not detail output formatting or explicitly rule out token rotation.

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

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

Schema coverage is 100%, so the schema already documents both bot and case parameters. The description adds no parameter-specific meaning beyond the operation itself, so baseline 3 is appropriate.

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

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

The description clearly states the operation: 'Возвращает токен бота в открытом виде' — a specific verb, resource, and even the output form. It is recognizable as distinct from siblings like bots_get, but it does not explicitly name or differentiate against any sibling, so it falls short of a 5.

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

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

The description gives an explicit usage condition: request the token only if the user directly asks, and do not repeat it unnecessarily. It provides clear context and a strong exclusion rule, though it does not mention alternatives or broader when-not-to-use scenarios.

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

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

Beyond the annotations it discloses meaningful behavior: the token is validated by a live platform request and stored encrypted, changing token or mode restarts a running bot, an archived record is restored with its scenarios and dialogs, and a connected bot's platform is immutable. These are exactly the side effects and constraints an agent needs before invoking a non-idempotent, open-world write.

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?

Five tight sentences, front-loaded with the parameter-based mode split, then the token handling, then the restart and platform-immutability caveats. No sentence is redundant and none repeats the schema verbatim.

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

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

For an 11-parameter upsert tool with nested objects and no output schema, the description covers the create/restore/update flows and their consequences sufficiently. Return values need not be explained without an output schema, so nothing essential is missing.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds cross-parameter semantics the schema states only piecemeal: that `bot` presence routes between create/restore and update, and that `platform` is frozen once connected. That is genuine value over the per-field schema text.

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

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

The description names the specific verb and resource and, crucially, splits the tool into two distinct operations keyed on the presence of the `bot` parameter: connect/restore when absent, reconfigure when present. This distinguishes it cleanly from siblings like bots_get, bots_delete, bots_control, and bots_detach.

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

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

It states exactly when to omit `bot` (connecting by token or restoring from archive) versus when to supply it (changing settings), which is real selection guidance. It stops short of naming any sibling alternative or exclusion, so it does not reach a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds that this reflects a 'live runtime' with uptime/updates/errors, which is useful behavioral context, but says nothing about freshness, auth needs, or what happens when a bot is offline.

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

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

A single compact sentence with no filler, and the returned facets are front-loaded. It is perhaps overly terse for a tool with an undocumented default-case fallback, but nothing is wasteful.

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?

There is no output schema, so the description does useful work by naming the returned fields (uptime, updates, errors, check time). However it omits usage context and any indication of refresh semantics or failure states, leaving gaps for an operational-status 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% with only two parameters (bot, case), and the schema already explains the default-case fallback behavior in detail. 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?

Names a specific resource and enumerates the returned runtime facets (uptime, updates, errors, check time), so an agent knows this returns live operational state. It does not differentiate itself from close siblings like bots_get or bots_journal, which also surface bot state, so it falls short of a 5.

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

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

There is no indication of when to call this versus bots_get, bots_journal, or bots_webhook_check, nor any prerequisites or exclusions. The agent is left to infer the use case from the field list 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?

Annotations cover safety (readOnly=false, destructive=false, openWorld=true), and the description adds meaningful context beyond them: upsert behavior, that secret-marked values are not returned back, and the allowed key charset. This is genuine behavioral disclosure not found in the structured fields.

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

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

Four tight sentences with the core action front-loaded, followed by upsert, secrecy, and key-format details in order of importance. Dense and free of filler, though a slightly more explicit routing sentence could be added.

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 output schema, the description still covers upsert semantics, secret-value behavior, and key constraints, which is enough for an agent to call a 4-parameter mutation correctly. Only explicit when-to-use guidance is missing.

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

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

Schema coverage is already 100%, so the baseline is 3, but the description adds the key character-set rule (Latin letters, digits, underscore, dot) that the schema only illustrates with a single example, plus the secret round-trip caveat. That is added value beyond the schema.

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

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

States a specific verb+resource (sets the variables substituted into scenario texts) and clarifies what those variables are (prices, addresses, links). It is clearly distinguishable from sibling bots_* tools, though it does not explicitly name an alternative.

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

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

Usage is implied through the upsert semantics (existing keys update, new ones are created), which tells the agent this is the write path for variables. However, there is no explicit when-to-use vs alternatives guidance or prerequisites, so it stays at the minimum viable level.

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

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

Annotations already mark the tool as read-only and idempotent; the description goes further by stating that no token or key is ever exposed from the address and that the output states whether the address matches the panel's expectation. This adds safety and interpretation context beyond the annotations.

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

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

Three sentences, each meaningful: report contents, diagnostic use-case, and privacy caveat. Key information is front-loaded in the first sentence. No filler or repetition.

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

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

For a simple diagnostic tool with two documented parameters and no output schema, the description covers all relevant expectations: what the report contains, what insight it provides, and the security guarantee about secrets. Nothing essential is missing.

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

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

Schema description coverage is 100%: both bot and case are described in the schema, including the default fallback for case. The description adds no parameter-level detail, so it stays at the baseline 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?

The description names a concrete resource ('Отчёт самой платформы') and specifies the exact outputs: delivery address, count of pending updates, and last delivery error. This clearly distinguishes bots_webhook_check from action-oriented siblings like bots_webhook_rotate.

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

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

It gives an explicit trigger scenario: use when a webhook-mode bot is silent but the panel side looks healthy ('Единственный способ понять...'). It does not, however, spell out when not to use it or name alternative diagnostic tools.

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

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

The annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds that no bot is required and that it returns a public address plus conditions, but does not disclose auth requirements, rate limits, or response format beyond that.

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

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

Two short sentences with no waste, front-loading the main resource and immediately clarifying the bot-not-required condition.

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 info tool with one optional parameter and rich annotations, the description is sufficient: it explains what is returned and that no bot is needed. It could be slightly more complete by stating the read-only nature explicitly, but the annotations already cover that.

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

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

Schema description coverage is 100% and the single optional 'case' parameter is fully described in the schema. The description adds no parameter-level detail; baseline 3 is appropriate 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 names the returned resource ('public address of the panel and conditions for enabling webhook mode') and adds a clarifying constraint ('bot not required'), making the tool's output clear. However, it lacks an explicit verb and does not differentiate itself from siblings like bots_webhook_check or bots_webhook_rotate.

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

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

Usage is implied: checking conditions before enabling webhook mode and the note that no bot is required hint at when the tool is relevant. But there is no explicit when-to-use/when-not-to-use guidance or mention of alternatives such as bots_webhook_check.

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

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

Annotations already mark destructiveHint=true, and the description adds that the old address 'stops working forever' (перестаёт работать навсегда), reinforcing irreversibility. It also reveals a new side effect: the running bot restarts (работающий бот перезапускается), which annotations don't cover. This gives valuable operational context beyond the structured hints.

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

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

Three short sentences in Russian, each with a distinct purpose: action, condition, and side effect. No filler words, and the main verb appears in the first sentence, front-loading 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?

For a destructive, non-idempotent tool with no output schema, the description covers the key aspects: what it does, when to use it, and permanent consequences. It lacks explicit permission requirements, but given the annotations and schema, it is thorough enough for an agent to invoke the tool correctly.

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

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

The schema already describes both parameters (bot and case) with 100% coverage, so the baseline is 3. The description doesn't add parameter-specific semantics, but the schema does the heavy lifting. No additional meaning is provided by the description.

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

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

The description clearly states the tool 'issues a new secret webhook address' (Выдаёт боту новый секретный адрес вебхука) for the bot, indicating a rotation action. It distinguishes from sibling bot tools (bots_get, bots_save, bots_delete) by focusing specifically on address rotation. The title 'Сменить адрес вебхука' aligns perfectly.

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

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

The description explicitly says this is needed 'if the old address leaked' (если старый адрес утёк), giving a clear trigger for use. It warns that the previous address stops working forever, implying it is not for routine changes. It doesn't name alternatives but provides sufficient context for when to use it.

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

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

Annotations already declare the mutation profile (readOnly=false, destructive=false, idempotent=false, openWorld=true), so the safety bar is low. The description adds one genuinely useful behavioral fact — attachment is only permitted while the broadcast is a draft or not started. It omits any note on permissions, replacement semantics, or the non-idempotent behavior.

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

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

A single front-loaded sentence with no filler; verb and object come first. It is arguably terse for a mutation tool, but nothing is wasted.

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

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

For a mutation tool with annotations covering the safety profile and a fully documented schema, the description is minimally adequate. It omits success/error behavior, whether an existing attachment is replaced, and permission requirements, leaving gaps for an agent handling failure cases.

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 parameter is documented there, including the 20 MiB size limit and MIME auto-detection. The description adds no parameter detail 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?

States a specific verb (attaches), a specific resource (a local file), and a precise target (a broadcast). The scope qualifier 'draft or not-yet-started broadcast' clearly separates it from broadcasts_detach and broadcasts_start, though no sibling is named explicitly.

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

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

The phrase 'к черновику или ещё не начавшейся рассылке' acts as a clear precondition: the broadcast must not yet be running. This tells the agent when the tool is valid, but it names no alternative tool and gives no explicit when-not guidance.

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

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

Annotations declare non-destructive, non-idempotent, open-world, but the description adds genuinely useful behavior: already-sent messages cannot be recalled and counters remain, i.e. the operation is a partial, irreversible-in-effect stop. It does not contradict destructiveHint=false since no data is deleted. Lacks note on permissions or response, keeping it from a 5.

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

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

Three compact sentences, effect stated first, then the two sibling routes. Every clause earns its place with no filler.

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

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

For a mutation tool with no output schema, the description covers the core outcome and the relevant alternatives, and annotations carry the safety profile. It stops short of noting permission requirements or confirming what the call returns, which would complete the picture.

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

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

Schema description coverage is 100% and both parameters (case, broadcast) already document names/IDs and the default-case behavior in the schema itself. The description adds nothing about parameter format or defaults, 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 and resource ('Останавливает рассылку') and immediately clarifies the effect ('то, что ещё не ушло, не уйдёт'), which distinguishes it from broadcasts_delete and broadcasts_retry. An agent can pick this over the siblings without opening any schema.

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

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

Explicitly routes to alternatives with conditions: retry failed sends goes to broadcasts_retry, creating a new draft from this broadcast goes to broadcasts_duplicate. This is exactly the when/when-not guidance the dimension asks for.

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

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

Beyond the destructiveHint=true annotation, the description discloses what actually gets destroyed (the broadcast plus its report), a required precondition (stop a running broadcast first), and the irreversible nature of sent messages. This is meaningful behavioral context the structured fields do not carry.

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

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

Two terse sentences with no filler; the destructive scope is front-loaded and the precondition/warning follow in priority order.

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 annotations already covering the safety profile and a fully documented schema, the description supplies the essential extra context (report deletion, stop-first precondition, irreversibility). Minor gap: it doesn't reinforce the confirm_name confirmation requirement, though the schema covers it.

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

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

Schema description coverage is 100%, so all three parameters (case, broadcast, confirm_name) are already fully documented in the schema. The description adds no format or meaning beyond what the schema provides, which is the expected 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?

States a specific verb and resource ('Удаляет рассылку и отчёт') and even adds the extra scope that the associated report is deleted too. However, it does not name or contrast the sibling it is easily confused with (broadcasts_cancel), leaving differentiation to inference.

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

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

Provides a clear precondition ('Идущую сначала остановите') and an explicit limitation ('отправленное не отзывается'), which tells the agent when this tool is appropriate and when it is not. It stops short of naming the alternative tool (broadcasts_cancel) directly.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true, so the agent knows this mutates state safely without destruction. The description adds the precondition that the broadcast must be a draft or not yet started, which is useful behavioral context beyond annotations. However, it does not clarify whether the attachment itself is deleted or merely unlinked, nor does it describe permissions or error behavior.

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

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

A single, front-loaded sentence with no redundancy. It delivers the essential scope constraint immediately.

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 mutation with full schema documentation and annotations covering mutation/safety, the description's scope constraint is sufficient to invoke correctly. It omits return-value detail, but no output schema exists, and the precondition is the main behavioral nuance.

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% for both parameters (case, broadcast), so the schema already provides full semantic detail. The description adds no parameter-level information, making the baseline 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?

States a specific verb (Снимает вложение) and resource (черновика или ещё не начавшейся рассылки), distinguishing it from broadcasts_attach by direction and from broadcasts_delete/cancel by scope. The qualification 'draft or not-yet-started' helps identify the tool, though it does not name a sibling alternative explicitly.

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

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

The description implies usage by restricting to drafts or not-yet-started broadcasts, which serves as a when-to-use condition. It offers no explicit when-not-to-use guidance or alternatives, leaving the agent to infer that other broadcast states are handled by broadcasts_cancel or broadcasts_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?

Annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=false) already signal a non-destructive write. The description adds genuinely useful context: the copy is never sent, and only_missed filters out recipients of the original — exactly the behavioral facts an agent needs before invoking a duplicate 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?

Two short sentences, with the most decision-relevant fact ('Копия не отправляется') front-loaded and no filler. The phrasing is clipped and slightly telegraphic, which costs a point relative to a fully self-contained statement.

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

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

There is no output schema, and the description does not say what the draft contains or where it lands after duplication, nor does it clarify required context for the broadcast/case parameters. It covers the critical 'not sent' question but leaves the agent to infer the rest.

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 are documented in the schema (case, broadcast, only_missed). The description only re-states only_missed with slightly more precision ('получил исходную рассылку'), adding marginal value over the schema 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 title 'Скопировать рассылку в черновик' states a specific verb+resource (copy broadcast into draft), and the description confirms a copy is produced. It does not distinguish itself from siblings like broadcasts_save or broadcasts_retry, but the copy-to-draft action is unambiguous.

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

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

The description says nothing about when to duplicate versus when to use broadcasts_save, broadcasts_attach, or broadcasts_start. There are no prerequisites or exclusions offered; the agent must infer usage from the name and title 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered by structured data. The description adds no behavioral context of its own — no scope, no permission note, no error behavior — it only lists the fields of the returned 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 a single short fragment with no padding, so there is no wasted text. However, the structure is a bare noun list rather than a front-loaded statement of purpose, so brevity here reflects under-specification as much as 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?

With no output schema, the description does carry the burden of describing what comes back, and it does imply the returned object's composition (text, buttons, attachment, targeting, state). But it omits what the tool does, its scope, and any behavior, leaving the definition only minimally viable for a 2-parameter get 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 'case' and 'broadcast' are documented in the schema, including fallback resolution for 'case'. The description contributes nothing about either parameter, so the baseline 3 for schema-carried semantics 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 never states a verb or an action — it only enumerates the broadcast's contents ('текст, кнопки по рядам, вложение, условия отбора и состояние'). An agent can infer that this returns broadcast details, which is better than a pure restatement of the title, but the tool's actual operation is left to inference and is not distinguished from siblings like broadcasts_preview or broadcasts_save.

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 broadcasts_list (to enumerate) or broadcasts_preview (to render). The agent must guess the retrieval 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?

Annotations already establish readOnlyHint/idempotentHint/non-destructive, so the safety profile is covered. The description adds genuine domain behavior beyond that: it interprets the delivery counters (skipped = user blocked the bot) and explains what each lifecycle state means operationally (draft is still editable and launchable, scheduled waits for the next sender pass), which an agent cannot derive from the enum 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?

Two sentences, front-loaded with what the tool returns before drilling into status states; nothing is off-topic and there is no filler. The parenthetical about skipped recipients is colloquial but still informative, so the density stays justified.

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, idempotent list tool with no output schema, the description covers what is returned, the counter meanings, and the full status vocabulary. Annotations carry the safety profile and the schema carries every parameter, so nothing an agent needs to call this correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description goes further by expanding each state beyond the schema's terse 'live — scheduled/running; done — done/cancelled' mapping, clarifying what draft, running, cancelled and failed actually represent. This meaningfully enriches the status filter semantics rather than restating them.

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

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

The description names the resource (рассылки дела) and enumerates the fields returned — selection conditions, text, and delivery counters — so an agent knows this is a list/read of case broadcasts. It never contrasts itself with siblings like broadcasts_get, broadcasts_targets, or broadcasts_start, so routing still requires inference, but the purpose itself is unambiguous.

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

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

There is no explicit when-to-use guidance and no naming of alternatives (broadcasts_get, broadcasts_targets, broadcasts_preview all live in the same namespace). The status vocabulary hints at filtering, but the agent is left to infer when this tool is the right choice versus the other broadcast tools.

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

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

With readOnlyHint=true already covering side-effect safety, the description adds genuinely useful behavior: it saves nothing, caps the preview at 50 by freshness, counts silenced conversations, and surfaces warnings (empty/too-broad selection, unknown substitutions). It does not detail the exact response shape, but the annotation already carries the safety profile.

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?

Dense but front-loaded: the preview outcome and the 'cannot be recalled' motivation come first, the save-nothing note and selection rule follow. Slightly long but every clause conveys distinct information.

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

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

For a 14-parameter tool with a nested audience object and no output schema, the description compensates by describing what the preview returns (counts, first-50 listing, silenced count, message warnings) and clarifying selection defaults. Nothing essential for correct invocation is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds cross-tool semantics not present in the schema: audience conditions are 'the same as the conversation list' and an empty condition set selects all counterparts. That meaningfully helps interpret the 14 parameters without re-listing them.

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

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

States a specific verb+resource: a pre-send estimate of a broadcast that reports how many conversations match, who (first 50), how many silenced the bot, and message problems. It also names the sibling it is not ('черновик заводит broadcasts_save'), so the agent can distinguish it from the save/start 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?

Explicitly routes usage: 'смотреть надо здесь' before sending because 'Разосланное не отзывают', and points to broadcasts_save for creating the draft. It also states the selection semantics (no conditions = all counterparts), giving clear when-to-use context.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so safety is largely covered. The description adds genuinely useful scope behavior beyond that: only undelivered recipients are targeted, and already-delivered recipients are not re-messaged. It omits permission requirements and whether the action can be undone, keeping it from a 5.

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

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

Two short sentences, zero filler, with the core action front-loaded and the non-duplication guarantee following. Well-sized for the complexity.

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 full schema coverage, rich annotations, and no output schema, the description supplies enough to call the tool correctly: it discloses the scope of the retry. Only the absence of any routing hint toward alternative broadcast tools leaves a minor gap.

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

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

Schema description coverage is 100%, and the schema explains all three parameters including the case-default fallback logic and confirm_name's role. 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?

States a specific verb+resource: resends undelivered messages, which cleanly distinguishes it from broadcasts_start, broadcasts_cancel, and broadcasts_delete. It stops short of explicitly naming which sibling to use instead, but the action itself is unambiguous.

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

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

The description implies the usage context (retrying a broadcast that partially failed) via 'недошедшие сообщения', but never states the prerequisite or when to prefer it over broadcasts_start or broadcasts_save. Usage is left to inference.

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

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

Annotations only cover the safety profile (write, non-idempotent, open world); the description adds non-obvious behavior: drafts never send until broadcasts_start, edits replace audience conditions wholesale rather than merging, omitted conditions leave prior ones intact, and HTML is validated at save time because the platform would otherwise reject the message for all recipients at once.

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

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

Front-loaded with the central create/edit branch, then lifecycle, mutation and validation semantics; six dense sentences with essentially no filler, though the paragraph is tightly packed for a 17-parameter tool.

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

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

For a 17-parameter, nested-object mutation tool with no output schema, the description supplies the lifecycle, mutation-replacement, and validation context an agent needs to call it correctly; per-parameter detail is fully carried by the schema.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds cross-parameter semantics the schema states only locally: the absent-vs-present role of `broadcast`, and the replace-not-supplement rule for audience fields on edit.

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 first sentence states a specific verb+resource branching: without `broadcast` it creates a draft, with it, edits an existing draft or scheduled broadcast. It distinguishes itself from siblings by naming broadcasts_start and broadcasts_cancel as the routes for other lifecycle states.

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

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

Explicit when-to-use rules: omit `broadcast` for a new one, pass it to edit; an already-started broadcast cannot be edited and must go through broadcasts_cancel; the bot can only be swapped after detaching the attachment. Alternatives and exclusion conditions are stated rather than implied.

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

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

Beyond the annotations (destructiveHint=true, openWorldHint=true), the description explains the irreversible consequence: 'Отправленное не отзывается ни у одного получателя' (sent cannot be recalled), and reveals queueing, scheduling via run_at, and the all-recipients risk. This significantly exceeds the structured annotations.

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

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

Four short sentences, each with a distinct purpose: queueing, irreversibility warning and preview, scheduling, and cancellation. The action is front-loaded and there is no filler.

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

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

For a three-parameter tool with no output schema, this description is unusually complete: it covers the core action, the main risk and mitigation, scheduling semantics, and the follow-up cancel action. Nothing essential for a correct invocation is missing.

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

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

The schema already documents every parameter (100% coverage), so the baseline is 3. The description adds rationale for confirm_title as an exact-title confirmation and clarifies scheduling behavior with run_at, adding semantic value beyond the schema.

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

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

The description immediately states a specific action and scope: 'Ставит черновик в очередь' (puts a draft into the send queue), which clearly means starting a broadcast. It also distinguishes itself from adjacent siblings by referencing broadcasts_preview and broadcasts_cancel, and from broadcasts_save by emphasizing the draft is already prepared.

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

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

It gives explicit workflow guidance: first use broadcasts_preview to check recipients, and use broadcasts_cancel for anything not yet sent. The warning that an empty selection means all bot interlocutors tells the agent when to be cautious and what to check beforehand.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the description only needs to add context. It mentions that the panel handles filters and pages, which is vague and slightly at odds with the schema's own filter/pagination params (q, case, limit, offset), and says nothing about ordering, response shape, or access requirements.

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

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

The first sentence is short and front-loads the essential outcome. However, the second sentence about the panel handling filters and pages is ambiguous and arguably redundant given the schema exposes filter and pagination parameters, so it does not fully earn its place.

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

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

For a read-only report with no output schema, the description does sketch what is returned (delivery status plus reasons), and annotations carry the safety profile. Still missing are usage context versus sibling broadcast tools and any parameter clarification, leaving the definition minimally adequate.

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 67% (offset and status undocumented), which is below the 80% threshold where the schema alone justifies a baseline 3. The description adds no parameter meaning at all—no explanation of the q/case/status filters, the mandatory broadcast identifier, or the panel-handling note's relation to limit/offset.

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?

Together with the title ('Отчёт по получателям рассылки'), the description 'Кому дошло, кому нет и почему' clearly conveys a broadcast-recipient delivery report showing who received, who failed, and why. The purpose is understandable, but the description itself names neither the verb (report/list) nor the resource (broadcast recipients), and it does not distinguish this from siblings like broadcasts_get or broadcasts_list.

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

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

There is no when-to-use or when-not-to-use guidance and no reference to any alternative tool such as broadcasts_get or broadcasts_list. The only guideline-like sentence ('Фильтры и страницы обрабатывает панель') describes filtering/pagination handling, not 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?

Annotations already declare destructive=true, non-idempotent and open-world. The description adds real behavioral value beyond them: that a message is genuinely delivered to a live dialog on behalf of the broadcast bot (not simulated), which is the key fact an agent needs before triggering it. It still omits rate limits or side effects of the send.

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

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

A single front-loaded sentence that leads with the most consequential fact ('Реально отправляет') and wastes no words.

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

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

With 100% schema coverage, full annotations and no output schema, the description only needs to add behavioral framing, which it does. It could note that confirm_name is a safety gate, but for a destructive send the essential fact is present, so it is nearly complete.

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

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

Schema coverage is 100%, so each parameter (case, dialog, broadcast, confirm_name) is already documented in the schema. The description only refers to 'the selected dialog', adding no syntax or selection detail 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?

States a specific verb and resource: it sends one real message to the selected dialog as the broadcast bot. The word 'проба' (trial) and 'одно сообщение' (one message) differentiate it from a full launch, though no sibling is named explicitly.

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

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

'Реально отправляет' (actually sends) implicitly contrasts with a preview/dry-run, so the intended use — a trial send before launching — is inferable. However, no alternative sibling (broadcasts_preview, broadcasts_start) is named and no prerequisites or when-not-to-use are given.

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

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

Beyond the destructiveHint annotation, the description adds concrete details: which entities are destroyed, and that deletion cannot be undone ('Восстановить нельзя'). This gives the agent a clear picture of the irreversible destructive scope, which is more than the annotation 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?

The description is just two sentences, both information-dense. The first states the action and its scope, the second states irreversibility and the alternative. There is no redundant or filler content, making it optimally 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 destructive mutation tool with no output schema, this description is fully complete: it tells what is deleted, warns about irreversibility, and gives an alternative for a milder action. Combined with the schema's 100% parameter coverage, the agent has all the information needed to invoke it correctly.

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

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

Both parameters (case, confirm_name) have full schema descriptions with 100% coverage. The description adds no additional parameter-level detail, so the baseline of 3 applies; there is no need for the description to repeat 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 description clearly states the tool deletes an entire case ('Удаляет дело целиком') and enumerates exactly what gets deleted (bots, scenarios, correspondence, participants, roles). It also distinguishes itself from archiving via cases_save, making it unambiguous.

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

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

The description explicitly provides an alternative: 'Чтобы просто убрать дело из списка, используйте cases_save с archived=true' (to simply remove from list, use cases_save with archived=true). This tells the agent when not to use this tool, which is exactly the needed guidance.

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

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

Annotations already provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful context about what the returned case card contains, including current user rights in the case and the list of summary categories. No contradiction with annotations.

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

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

The description is a single dense sentence with no filler words. It lists multiple summary categories, which is informative, but the long list makes it slightly heavy—still reasonably concise for the richness it conveys.

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 two optional parameters, no output schema, and strong annotations, the description is sufficient for an agent to know what the tool returns: user permissions and a composite case summary. It also clarifies the date-bound correspondence aspect referenced by the 'days' parameter.

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

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

Schema description coverage is 100%, and both parameters are already documented in the input schema: 'case' explains the matching and fallback behavior, and 'days' says 7/14/30 with a default of 7. The description does not need to add further parameter-level meaning.

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

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

The description clearly defines the tool as a case card ('Карточка дела') that returns the current user's rights and a summary of bots, dialogs, correspondence, deferred actions, knowledge bases, and participants. This distinguishes it from cases_list, cases_save, and cases_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?

The description implies the tool is used for viewing/opening a single case with details and rights, but it does not explicitly state when to use it instead of sibling tools like cases_list or bots_get. No when-not-to-use or alternative tool mention is present.

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

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

Annotations already mark destructiveHint=true and readOnlyHint=false. The description adds a valuable behavioral constraint: the owner cannot leave and must transfer the case first. This goes beyond the annotation flags and provides real context about preconditions and limitations.

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

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

Two concise sentences, front-loaded with the primary action followed by the exception and alternative. Every word earns its place; there is no redundancy or unnecessary elaboration.

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 action with one parameter and no output schema, the description covers the core action, the key restriction, and the alternative. It does not mention edge cases like non-participant behavior, but given the annotations and simplicity, it is nearly complete.

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

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

The input schema has 100% coverage for the single parameter 'case' with a clear description ('Дело: название или идентификатор'). The tool description does not add further detail about the parameter, so baseline 3 is appropriate.

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

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

The description clearly states the tool's function: 'Убирает вас из числа участников дела' (removes you from case participants). It specifies the action (remove) and the resource (your membership in the case), distinguishing it from sibling tools like case_transfer, which transfers ownership, and members_remove, which likely removes other members.

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

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

The description explicitly states when the tool cannot be used ('Владелец выйти не может') and provides a clear alternative: 'сначала нужно передать дело другому участнику (case_transfer)'. This gives the agent actionable guidance on when to use this tool versus the case_transfer 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?

Annotations already declare the operation read-only, open-world, idempotent, and non-destructive. The description adds value by specifying the access scope and response contents (role, rights, bot/unread counters), enriching behavioral understanding without contradicting the annotations.

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

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

The description is a single, front-loaded sentence that immediately conveys the tool's purpose and scope. It contains no filler or redundant information relative to the annotations.

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 straightforward list tool with one optional parameter and rich annotations, the description is sufficient: it names the resource, access scope, and returned data fields. It does not describe pagination or the exact array format, but the absence of an output schema and the tool's simplicity make this a minor gap.

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

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

The only parameter (include_archived) is fully described in the schema with a default value, and the schema coverage is 100%. The description does not add parameter details, but the baseline of 3 is appropriate because the schema carries the semantic burden.

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 tool lists all accessible cases ('Все дела, к которым есть доступ') and specifies the included data: role, rights, bot and unread counters. This clearly identifies it as the list operation for cases, distinguishing it from sibling tools like cases_get or cases_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?

The description provides context that the tool returns only cases the user has access to and includes an optional archived filter, but it does not explicitly state when to prefer this over cases_get or other list tools. Usage is implied rather than directly contrasted with alternatives.

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

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

Annotations already declare this as a non-read-only, non-destructive, non-idempotent write tool. The description adds meaningful side-effect detail: creating a case makes the caller owner and deploys five roles, while updating can change fields or archive the case.

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

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

Two compact sentences with no wasted wording. The create case is front-loaded, followed immediately by the update/archive case.

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 7-parameter save tool with no required parameters and no output schema, the description covers the main create/update split and key side effects. It omits the nested 'settings' parameter and the unarchive behavior that the schema mentions.

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 each parameter is already documented. The description synthesizes the role of the 'case' parameter and lists some editable fields, but adds little 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 states a specific create-or-update purpose and clearly explains the two modes controlled by the 'case' parameter. It does not, however, explicitly differentiate itself from sibling case tools such as cases_get, cases_list, or cases_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?

It gives clear context for both modes: omit 'case' to create a new case, provide it to modify an existing one. It does not mention when to avoid this tool or name alternative case-management tools.

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

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

The description goes beyond the destructiveHint annotation by explaining exactly what happens to the previous owner (demoted to admin, loses re-transfer rights) and that only the new owner can transfer back. This provides critical behavioral detail not available elsewhere.

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

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

The description is two sentences long, front-loaded with the core action, and every clause adds value. No filler or redundancy.

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

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

For a destructive, non-idempotent tool with no output schema, the description explains the transfer, the consequences for both parties, and the irreversible nature. It lacks explicit prerequisites (e.g., current owner must invoke) but is otherwise complete for safe 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 descriptions cover 100% of parameters, so the baseline is 3. The tool description does not add additional parameter meanings beyond the schema, leaving confirm_name and member semantics to the schema.

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

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

The description clearly states the action: making another participant the owner of a case. It distinguishes from related tools like cases_leave or cases_delete by specifying the transfer of ownership and its consequences, so the purpose is unambiguous.

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

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

The description implies usage scenarios (when you need to change case ownership) but does not explicitly contrast with alternatives or state when not to use it. The context is clear enough for an agent to infer, but explicit guidance is missing.

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

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

Annotations already declare destructiveHint=true and idempotentHint=false, so the danger is known. The description adds genuine value beyond that by disclosing the collateral effect ('снимает её связи с диалогами') and the confirmation safeguard requiring the exact name. It does not address permissions or reversibility, so not a 5.

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

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

Two short sentences with zero filler. The destructive action is front-loaded and the confirmation requirement follows immediately.

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 output schema, the definition covers the action, its side effect, and the confirmation guardrail; annotations cover the safety profile. It omits any mention of the returned result or failure behavior, but for an agent deciding whether/how to call it, this is nearly complete.

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

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

Schema coverage is only 33% (only 'case' is described). The description compensates for confirm_name by explaining it must be the verbatim name for confirmation, which is genuinely useful. However counterparty_id remains undocumented and no format/behavior detail is added, so it does not fully cover the 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?

States a specific verb (удаляет) and resource (карточку контрагента) and even names a side effect — removing links to dialogs. This clearly separates it from sibling read tools like counterparties_get/list. It does not explicitly name which sibling it differs from, keeping it just short of a 5.

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

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

The description implies the destructive use case and gives a precondition (exact name needed for confirmation), but offers no explicit when-to-use/when-not guidance or named alternatives. Usage is only inferable from the 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds real context beyond that: the required chat.view permission and the fact that a missing link is reported rather than erroring.

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

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

Three short sentences, each earning its place, with the conditional modes front-loaded ahead of the permission note. Zero 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?

No output schema, but the description explains what each mode returns, including the negative case (no link). For a read-only lookup with idempotent/non-destructive annotations, this is nearly complete; only the search/case parameters go unexplained.

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 only 33%—dialog_id has no description in the schema, and the description usefully explains its role as the mode switch. But 'case' and 'search' carry no meaning in the description, leaving one undocumented param and one only partially clarified by the schema.

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

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

The description states a specific dual-mode behavior: without dialog_id it lists dialogs available for linking, with dialog_id it returns the linked counterparty. This is a clear verb+resource, though it never names a sibling tool to differentiate against (e.g. counterparties_link, counterparties_get, dialogs_list).

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 with/without dialog_id split implies when each mode applies, which is useful conditional guidance. However, it gives no explicit when-to-use versus alternatives, no exclusions, and does not route the agent to the sibling tools that perform the actual linking.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and non-destructive. The description adds real value beyond them: the dialogs field is gated on the chat.view right, which an agent cannot learn from the annotations. It still omits what happens on a missing/unauthorized counterparty, so not a 5.

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

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

Two short, front-loaded sentences: the entity and its key source come first, then the visibility caveat. No filler or repetition.

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

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

For a read-only single-entity fetch with no output schema, the definition covers the required identity source and the one behavioral caveat (dialog visibility). It leaves the card's contents and error behavior unstated, but annotations carry the safety profile, so this is nearly 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 only 50% – 'case' is documented in the schema but counterparty_id carries only a pattern. The description partially compensates by stating counterparty_id is a UUID sourced from counterparties_list, but adds nothing about the 'case' parameter's default-resolution behavior.

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 ('Карточка контрагента') and scopes it to a UUID obtained from counterparties_list, which separates it from that sibling. It does not distinguish itself from other counterparties_* siblings it could be confused with (e.g. counterparties_dialogs), so it falls short of a 5.

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

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

The phrase 'по UUID из counterparties_list' implies the workflow (list first, then fetch one) and the chat.view permission prerequisite is stated. However, it never says when NOT to use it or names an alternative for bulk/lookup-by-name needs, so guidance is implied rather than explicit.

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

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

Annotations already declare the write/side-effect profile (readOnlyHint=false, idempotentHint=false, destructiveHint=false). The description adds genuine behavioral context beyond them: it links exactly ONE dialog, and the panel rejects a non-matching previous link rather than silently overwriting. That explains the safety semantics of replace_counterparty_id, which annotations do not convey.

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

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

Two tight sentences, front-loaded with the core action and followed by the replace-mechanism caveat. No filler; every clause carries information.

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

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

For a 4-parameter mutation tool with no output schema and thin schema descriptions, the description covers the action and the replace-validation behavior but omits the case-selection and counterparty_id semantics. Adequate but leaves gaps an agent must resolve elsewhere.

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 only 25% (only 'case' is documented), so the description carries most of the burden. It usefully explains dialog_id (single, explicit) and replace_counterparty_id (must be the UUID of the source card), but says nothing about counterparty_id itself or the case parameter, leaving two required/optional params unclear.

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: linking one explicitly specified dialog_id to a counterparty card. The word "явно указанный" signals a direct/one-dialog link, implicitly distinguishing it from bulk/automated siblings like counterparties_reconcile. However, no sibling is named, so an agent must infer the boundary with counterparties_unlink/counterparties_dialogs.

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

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

Gives a real conditional instruction: pass replace_counterparty_id's UUID when transferring from another card. That covers one usage path, but there is no guidance on when to prefer this tool over counterparts like counterparties_reconcile or counterparties_unlink. Usage is implied rather than routed.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered without the description. The description does add useful context about the shape of the payload (contacts, notes, extra fields, linked dialogs), but says nothing about pagination, result ordering, or volume 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?

A single well-formed sentence with no wasted words, front-loading the resource and enumerating the returned sub-entities. It is concise, though arguably too terse to carry the tool's full semantics.

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

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

With no output schema, the description usefully sketches what a counterparty record contains, and annotations cover the read-only profile. However, it omits any explanation of the free-text 'search' parameter or the default-case resolution behavior implied by the schema, leaving the definition only minimally complete.

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

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

Schema coverage is only 50% (the 'search' parameter has no schema description), and the description supplies no parameter meaning whatsoever, so it fails to compensate for the gap. Only the 'case' parameter is documented, and that is done entirely in the schema, not the description.

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

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

The description names the resource (counterparties) and enumerates what it surfaces (contacts, notes, custom fields, related dialogs), but it uses no verb and never states that this is a list/retrieval operation. It does not distinguish itself from the very similar sibling counterparties_get, so an agent cannot confidently choose between them from the text 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 explicit when-to-use guidance, no mention of alternatives such as counterparties_get, counterparties_dialogs or counterparties_settings, and no stated prerequisites. Usage is only faintly implied by the plural resource 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?

Annotations declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false. The description goes further by clarifying the operation is server-side, uses current settings, and returns linked/created/skipped — information not conveyed by annotations. It doesn't detail side effects or permissions, but given the annotation coverage this is solid.

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

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

Two short sentences, front-loaded with the action and outcome. No wasted words, though the second sentence about manual links could arguably be merged or trimmed.

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

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

For a single-parameter, no-output-schema tool with annotations covering safety/side-effect hints, the description covers what the tool does, what it returns, and a key behavioral nuance (manual links ignored). Missing only explicit usage alternatives, but it is otherwise 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% for the single 'case' parameter, so the schema already explains its meaning and fallback behavior. The description adds nothing about the parameter, which is acceptable given full schema coverage — baseline 3.

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

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

The description states a specific verb and resource — 'Запускает серверное автоматическое сопоставление' (launches server-side automatic matching) — and names the outputs (linked/created/skipped). It is clearly distinct from siblings like counterparties_link/counterparties_get, though it doesn't explicitly name an alternative.

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

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

Implies usage via the phrase 'по текущим настройкам' (per current settings) and notes that manual links are handled by the panel itself, which hints at scope. But there is no explicit when-to-use/when-not guidance or reference to sibling tools like counterparties_link.

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

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

Annotations already declare mutation status (readOnlyHint=false) and open-world/idempotency hints, but the description adds critical behavioral detail beyond them: null clears a contact field, custom_fields replaces the whole map, dialog_ids must be explicitly selected, and only changed fields should be passed during an edit. These are meaningful mutation semantics not present in the structured data.

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

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

Three compact semicolon-separated clauses, front-loading the create/update condition first. Every sentence carries actionable information with no filler.

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

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

For a 9-parameter create-or-update mutation with nested objects and no output schema, the description covers the essential call semantics: create vs edit, required fields for creation, partial-edit behavior, null clearing, full replacement of custom_fields, and where link changes belong. No output-schema explanation is needed.

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 only 11%, so the description must compensate, and it does add key semantics: counterparty_id selects create vs update, name is required for creation, dialog_ids must be explicit UUIDs, null clears contact fields, and custom_fields replaces the map entirely. However, it does not cover every parameter (e.g., notes, case specifics are left to the schema), so it is strong but not 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 first sentence states a specific verb+resource and the condition that selects create versus edit: 'Without counterparty_id creates a card'. It also names the sibling tools for a related operation ('links of an existing card are changed via counterparties_link/unlink'). An agent can distinguish this save tool from counterparties_get, counterparties_list, and counterparties_delete without opening further schemas.

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

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

Explicit when-to-use guidance: omit counterparty_id to create, pass it to edit, and for creation name is required and dialog_ids must contain explicitly selected UUIDs. It also states the edit convention ('pass only changed fields'), the null behavior, and the alternative for link management. This gives clear conditions and alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds domain content only and does not disclose return behavior, pagination, or any other trait beyond the annotations.

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

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

It is a single short sentence fragment, tightly scoped and front-loaded with the settings categories. There is no filler, though the fragment lacks a verb.

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 settings-retrieval tool with read-only annotations and no output schema, the description still leaves key information missing: it never states the tool returns settings, nor how to invoke it relative to the save sibling. The agent must infer too much.

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

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

Schema coverage is 100% and the single optional 'case' parameter is fully documented in the input schema. The description adds no parameter syntax or constraints 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 names the resource and its contents (manual/automatic mode, criteria, variables) but provides no verb indicating whether it reads, writes, or manages settings. It therefore does not clearly distinguish this retrieval-side tool from siblings like counterparties_settings_save.

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

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

No guidance is given on when to use this tool versus counterparties_settings_save or other counterparty tools. An agent must infer that this returns settings while the sibling mutates them.

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

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

Annotations declare readOnlyHint=false and idempotentHint=false, so the agent knows this is a non-idempotent write. The description adds a key behavioral detail—only passed settings are changed, not a full replacement. However, it doesn't explain what happens to omitted settings, whether existing reconciliations are affected, or permission requirements. With annotations covering the safety profile, this is adequate but not rich.

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

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

Three short sentences, front-loaded with the core mutation behavior. The constraints are stated compactly. No wasted words, though the dependency between phone/email matching and the corresponding variables could be slightly clearer in ordering.

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 8 parameters at 13% schema coverage and no output schema, the description covers the most important behavioral constraints but leaves several parameters undocumented (case, mode, create_unmatched, match_platform_id) and doesn't explain the response or side effects. It's minimally complete but has clear gaps.

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

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

Schema coverage is only 13%, so the description must carry the load for 8 parameters. It does well: it explains the automatic-mode criteria constraint and the dependency that email_variable/phone_variable must be non-empty when matching is enabled. It doesn't explain case resolution, manual mode, or the boolean toggles like create_unmatched and match_platform_id, leaving gaps, but the critical conditional logic is covered.

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 says it changes only the transferred settings, and the title ('Изменить сопоставление контрагентов') names a specific action and resource. It's clear this is a settings-save tool, though it doesn't explicitly differentiate itself from the sibling counterparties_settings (which likely reads settings).

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

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

The description provides real when-to-use guidance: it names the alternative counterparties_reconcile for processing existing dialogs, and it implies this tool is for changing settings rather than reconciling. However, it doesn't state when to use manual vs automatic mode beyond the single criterion for automatic.

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

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

Annotations declare destructiveHint=false and idempotentHint=false; the description adds genuinely useful context by stating exactly what survives — the counterparty card and the conversation — which explains why the operation is non-destructive. It still omits whether re-running is safe and what happens if no link exists.

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

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

A single front-loaded sentence with no filler; the scope constraint is presented immediately. It is arguably too terse for the gaps it leaves, but as a structural matter there is no waste.

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