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

Annotations already cover idempotency (idempotentHint: true) and non-destructiveness (destructiveHint: false). The description adds the refusal condition but doesn't elaborate on edge cases like cancelling an already-cancelled operation. With annotations handling 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?

A single, concise sentence that front-loads the verb and purpose. No wasted words, and the key condition is stated immediately. It is efficiently structured for quick parsing by an agent.

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

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

For a simple cancel operation with one well-documented parameter, annotations covering idempotency and non-destructiveness, and an output schema present, the description provides enough context. It could explicitly reference confirm_action as the counterpart, but the condition makes the usage clear. Slight room for improvement, but not a 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 schema fully documents the only parameter (confirmation_id) with a description, and the tool description adds no extra semantics beyond what the schema already provides. With 100% schema coverage, a baseline score of 3 is appropriate.

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

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

The description clearly states the action (cancel), the target (prepared operation), and the condition (if the user refused). It distinguishes itself from the sibling confirm_action by indicating the opposite action, making its purpose unambiguous.

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

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

The description provides a clear context for when to use the tool (when the user refuses a prepared operation). It doesn't explicitly exclude other scenarios or name alternatives, but the condition implicitly differentiates it from confirm_action, giving sufficient guidance for an agent.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows this is a write/action tool. The description adds the context that it executes an already-prepared operation and requires prior user consent, which is helpful but not deeply informative about side effects or failure modes. It does not contradict annotations and provides modest additional context.

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

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

The description is two sentences long, front-loads the purpose, and places the critical usage constraint right after. Every sentence earns its place, and there is no redundant wording.

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

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

The tool has a single parameter, a full schema description, and an output schema, so the description does not need to explain return values. The description provides the essential operational guidance (execute only after confirmed preview), making it complete for an agent to call it correctly.

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

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

There is only one parameter, confirmation_id, and the schema description covers it fully ('confirmation_id из ответа инструмента'). The description adds no additional meaning beyond the schema, so the baseline score of 3 for high schema coverage applies.

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

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

The description states the tool executes a 'prepared operation' ('Выполнить подготовленную операцию'), which is a specific verb and resource. It clearly implies a confirmation/execution step rather than a read or list operation, and the user-consent condition distinguishes it from generic action tools. However, 'prepared operation' is somewhat generic and doesn't name a specific resource type, so it falls short of perfect clarity.

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

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

The description explicitly states when to call: 'Вызывайте ТОЛЬКО после того, как пользователь увидел preview и явно согласился выполнить именно эту операцию' (call only after the user saw the preview and explicitly agreed). This is a strong, unambiguous precondition that also implicitly tells the agent when not to call (before consent). It effectively differentiates this from siblings like cancel_action or other action 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 adds a key behavioral trait beyond annotations: 'Требует подтверждения пользователя' (requires user confirmation). This is valuable because annotations only say readOnlyHint=false and destructiveHint=false, which don't convey the confirmation requirement. The description also implies a write operation (adding a comment), consistent with readOnlyHint=false. No contradiction.

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

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

Two short sentences, front-loaded with the action and resource, followed by the critical confirmation requirement. No wasted words.

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

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

The tool is simple (3 params, all required, 100% schema coverage, output schema present). The description covers the core action and the confirmation behavior. It doesn't mention return values, but the output schema exists, so that's not required. The only minor gap is not explicitly routing to task_add_comment for task comments, but the entity enum makes the CRM scope clear.

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 three parameters (id, text, entity). The description adds no additional parameter-level meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Добавить' = add) and resource ('комментарий в таймлайн лида, сделки, контакта или компании' = comment to the timeline of a lead, deal, contact, or company). It clearly distinguishes the tool from siblings like crm_create or crm_update by focusing on adding a comment to a timeline. It doesn't explicitly name a sibling alternative, but the resource and action are specific enough.

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

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

The description implies usage context: it is for adding comments to CRM entities, and the entity enum clarifies which object types are valid. It does not explicitly state when to use this tool versus alternatives like task_add_comment (for tasks) or crm_comments (for reading comments). The guidance is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the read-only safety profile is already known. The description adds the 'timeline' source context is useful but minimal, and no behavioral details such as pagination behavior, ordering, or handling of missing objects are disclosed.

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 concise phrase with no filler, and the core scope is front-loaded. It is not maximally effective because it is a noun phrase without a verb, but it is still lean and 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?

The output schema and annotations carry significant context, so the description does not need to explain return values or safety. However, the description itself is thin: it lacks an explicit operation verb, pagination semantics, and any indication of when to choose this tool over crm_add_comment. It is minimally viable 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 description coverage is 100% and completely documents id, start, and entity with types, enums, and descriptions. The tool description adds no parameter-level meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description identifies the resource ('comments') and source ('timeline of a CRM object'), so an agent can tell it returns comments rather than creating or updating them. However, it lacks an explicit verb such as 'get' or 'list' and does not name or differentiate against the sibling crm_add_comment.

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

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

There is no guidance on when to use this tool versus alternatives such as crm_add_comment or task_add_comment. No context, exclusions, or prerequisites are provided; the agent must infer usage entirely from the tool name and sibling list.

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

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

Annotations already indicate readOnlyHint=false (non-read-only) and destructiveHint=false. The description adds the behavioral detail that the operation requires user confirmation, which is not present in annotations. This goes beyond the structured fields and provides actionable context for the agent.

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

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

The description is exceptionally concise—two short sentences that front-load the core purpose and then state the confirmation requirement. There is zero redundancy or 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 creation tool with a rich schema and output schema available, the description covers the essential purpose and the confirmation requirement. It does not mention potential side effects beyond creation, but the annotations (openWorldHint=true) and schema compensate. Overall, the description is adequate for an agent to understand when and how to invoke 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?

The input schema has 100% description coverage for both parameters, including detailed examples for the 'fields' object. The tool description adds no additional parameter guidance beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description states a specific verb ('создать' – create) and the exact resource types (lead, deal, contact, company). This clearly distinguishes it from siblings like crm_update, crm_delete, and crm_list, which serve different operations.

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

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

The description explicitly notes that user confirmation is required, which is a key usage constraint for a mutating operation. However, it does not explicitly name alternatives or conditions for when to use this tool over crm_update or crm_create, though the purpose itself implies creation.

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

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

The description adds a significant behavioral trait—user confirmation is required—beyond what the annotations (destructiveHint, readOnlyHint, openWorldHint) already convey. It provides useful context about the interaction flow without contradicting any annotation.

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

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

The description is extremely concise—two short sentences—with the purpose front-loaded and the confirmation requirement following. 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 simple delete operation with only two documented parameters and an output schema present, the description covers the essential behavioral requirement (confirmation) and the entities involved. It does not explain return values, but the output schema likely handles 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% for both parameters (id and entity) with clear descriptions and an enum. The tool description itself adds no additional parameter-level detail, so the baseline of 3 is appropriate.

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

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

The description clearly states the action 'delete' and the specific CRM entities it applies to (lead, deal, contact, company), which matches the schema enum. This distinguishes it from siblings like crm_create, crm_update, and crm_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 description implies the tool is for deleting CRM entities and adds that user confirmation is required, giving clear usage context. It does not explicitly mention alternatives, but the purpose is unambiguous given the tool name and sibling set.

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, indicating a safe read operation. The description adds that the tool returns field metadata including custom fields (ufCrm...), which provides behavioral context beyond the annotation. No contradiction found.

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 consists of two concise sentences that front-load the purpose and then provide a usage hint. Every word earns its place with no redundancy or unnecessary detail.

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 metadata tool with one parameter and an output schema, the description covers purpose, usage, and content scope. Annotations cover read-only behavior, and the output schema handles return values, so nothing critical is missing.

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

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

The input schema fully documents the single 'entity' parameter with an enum and a clear description. The description does not add additional parameter semantics beyond what the schema already provides, so a baseline score of 3 is appropriate given 100% 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 clearly states that it provides a description of CRM object fields (names, types, requiredness, list variants) including custom fields. It distinguishes this tool from siblings like crm_get (which fetches a record) or crm_list (which lists records) by focusing on metadata rather than data.

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 instructs to use this tool before creating or changing a CRM entity, giving a clear usage context. It does not mention alternatives or when not to use it, but the guidance is sufficient for most cases.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety and non-exhaustive-world profile is covered. The description adds a small behavioral detail — the result is IDs rather than full entities — but does not disclose matching semantics (exact vs partial phone/email match) or multi-value result behavior. 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?

A single front-loaded sentence with zero wasted words. It does not repeat any schema content or annotation information, and it conveys the full purpose in one line.

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

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

The tool is simple: 3 parameters fully documented in the schema, an output schema present, and annotations covering the read-only and open-world profile. The description states the purpose accurately. The only missing element is usage guidance relative to siblings, which is already captured and penalized under usage_guidelines.

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%: type, entity, and values all carry meaningful descriptions in the schema, including enum options and the up-to-20-item limit. The tool description itself adds no parameter-level detail beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb (найти/find), a specific resource (IDs of leads, contacts, companies) and a specific method (by phone or email). The search-by-contact-info criterion naturally distinguishes it from siblings like crm_get and crm_list, 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?

The description gives no guidance on when to use this tool versus alternatives such as crm_list or crm_get, and no exclusions or prerequisites. The only contextual hint ('where to search; if not specified — in all') lives in the schema's entity parameter, which is parameter semantics rather than tool-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=true, so the agent knows this is a safe read operation. The description adds the behavioral detail that it returns 'all filled fields', which conveys the output scope (i.e., it does not return empty fields). This goes beyond the annotation and provides useful context, though it doesn't cover other behaviors like error handling or pagination (not applicable here).

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

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

The description is a single concise sentence that is front-loaded with the verb and resource, and it adds the 'all filled fields' qualifier without any fluff. Every word contributes to clarity.

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

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

Given the tool's simplicity (two parameters, both documented), the readOnlyHint and openWorldHint annotations, and the presence of an output schema, the description covers everything an agent needs to invoke it correctly. It specifies the input (ID and entity) and the output scope (all filled fields), 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%, with both 'entity' and 'id' having clear descriptions. The description adds no new parameter semantics; it only mentions 'by ID' and the entity types, which are already in the schema. Baseline of 3 is appropriate since 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 clearly states the action ('get') and the specific resource types (lead, deal, contact, company) and the key qualifier 'by ID' with 'all filled fields'. This distinguishes it from siblings like crm_list (which lists) and crm_find_by_contact_info (which searches by contact info), making the tool's purpose unambiguous.

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

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

The description does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. Usage is implied: use when you have an ID and need a single entity. However, without explicit guidance, an agent might not fully appreciate that this is the canonical ID-based fetch, distinct from list or search operations.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering safety and external data. The description adds a useful behavioral note ('Empty fields in response are omitted'), which is not in the annotations, but it does not elaborate on pagination, result format, or potential quirks 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?

The description is extremely concise—two short sentences with no filler. The primary purpose is front-loaded, and the additional behavioral note about empty fields is placed at the end. Every word earns its place.

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

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

For a read-only list tool with a rich input schema and an output schema, the description covers the essential purpose and one behavioral nuance. The output schema handles return format, and the schema covers defaults. The only minor gap is the lack of explicit guidance to use crm_get for single-record retrieval, but that is a usage-guideline concern rather than a completeness 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%, so the schema fully documents all six parameters. The description adds no parameter-specific meaning beyond the general 'by filter' phrase, which is already covered by the filter property's detailed schema description. Baseline 3 is appropriate.

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

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

The description clearly states the action (find/list) and the resource (leads, deals, contacts, companies) with a filter. It distinguishes this list operation from siblings like crm_get (which fetches a single record) and crm_create/update/delete, making the purpose unambiguous.

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

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

The description does not explicitly state when to use this tool versus alternatives, such as crm_get for retrieving a single record by ID. It implies a search/filter use case but provides no exclusions or routing guidance, leaving the agent to infer the distinction.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds semantic context about deal stages vs lead statuses and the downstream use of stage IDs, but it does not elaborate on response behavior or edge cases. With annotations present, this is acceptable 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?

The description is a single, compact sentence with the core subject front-loaded and a genuinely useful parenthetical about why stage IDs matter. There is no filler or redundant restatement of the tool name.

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 reference tool with two optional, fully documented parameters and an output schema, the description covers the essential scenario and cross-tool purpose. An explicit 'returns a list of stages/statuses' phrasing would make it unambiguous, but nothing critical is missing.

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

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

Schema description coverage is 100%, and the schema already documents entity values ('deal' vs 'lead') and category_id behavior. The description mostly restates the deal/lead distinction and emphasizes the stage ID's purpose, adding little new parameter-level meaning. 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 identifies the resource clearly: 'Воронки и стадии сделок или статусы лидов' (funnels and deal stages or lead statuses), and explains that the stage ID is needed for filtering and changing stageId. It lacks an explicit verb like 'list' or 'retrieve', which keeps it from a 5, but the object and scope are specific enough to distinguish it from entity-focused siblings like crm_list and crm_get.

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

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

The parenthetical gives a concrete usage context: the stage ID from this tool is required for filtering and for changing stageId. This is clear but not exhaustive — it does not name alternatives or state when not to use the tool, so it falls short of explicit when/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 already signal mutating/destructive behavior, and the description adds useful behavior beyond them: it performs partial updates and requires user confirmation. 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?

Three short sentences, front-loaded with the action and resource scope, followed by two necessary usage constraints. No filler or repetition of schema details.

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

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

With an output schema, rich input schema, and annotations covering safety, the description supplies the remaining operational context: partial update semantics, the fields example, and confirmation requirement. An agent has enough to call it correctly.

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

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

Schema coverage is 100%, so the schema carries the parameter details; the description still adds value by clarifying that only changed fields should be sent and gives a stage-transition example that maps to the fields object.

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

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

The description names a specific action ('change fields') and explicit CRM resources (lead, deal, contact, company), with a concrete example (moving a deal to another stage). This differentiates it clearly from sibling create/delete/get tools.

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

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

It states when to use it (update existing CRM objects) and gives operational guidance: pass only changed fields and expect user confirmation. It does not explicitly name alternatives or when-not-to-use conditions, but the context is clear.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds useful behavioral context: stages appear in order and each stage shows its tasks, which is more specific than the annotations 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 two short sentences with no filler. The core purpose is front-loaded, and the sibling routing is a separate, clearly scoped sentence.

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 board view with a complete input schema and an output schema available, the description covers what the tool returns, how it differs from scrum boards, and its read-only nature via annotations. Nothing essential is missing.

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

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

The input schema already fully describes all three parameters (group_id, max_tasks, include_completed), so the description does not need to add parameter details. The description adds no extra semantic information about parameters, which is acceptable given 100% 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 clearly states that this tool provides a project kanban view with ordered stages and their tasks, which identifies the resource and content. It lacks an explicit verb like 'list' or 'get', but it does distinguish itself from sprint_board by naming the scrum 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?

The description explicitly says 'Для скрама используйте sprint_board', which tells the agent to use a sibling tool for scrum contexts. This is a clear when-not-to-use and alternative routing, leaving no ambiguity about when this board is appropriate.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the read-only safety profile is known. The description adds a useful scope detail ('доступные пользователю вебхука') and points to follow-up tools, but it does not disclose any additional behavior such as default ordering, result limits, or relationship type.

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 filler: the first states purpose, and the second gives routing logic. It is appropriately sized for the tool's complexity and front-loads the core message.

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

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

The output schema, fully documented parameters, and annotations cover the basics, so no return-format explanation is required. The description adds the missing cross-tool context (how to proceed for scrum vs non-scrum) but could still be slightly more explicit about the meaning of 'type'.

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?

Parameter schema coverage is 100%: query, start, and include_closed each have clear descriptions. The description adds no extra parameter-level insight; the mention of 'type=scrum' refers to an output/domain concept rather than a documented input parameter, 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 begins with a specific action ('Найти' / find) and names the target resources: 'проекты, рабочие группы и скрамы' (projects, workgroups, scrums), scoped to the webhook user. The second sentence further distinguishes it from scrum-specific siblings, so an agent can easily tell this list tool apart.

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

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

It explicitly routes: 'Для type=scrum используйте scrum_sprints, sprint_board и scrum_backlog, для остальных — project_board.' This gives concrete conditions for choosing alternatives, which satisfies when/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 already declare readOnlyHint=true, so the agent knows it is a read operation. The description adds context about ordering and included fields (story points, epics), which is useful but does not go beyond that. 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?

A single concise sentence that clearly states the purpose with no redundancy. It is front-loaded with the core information and is appropriately sized for a simple list 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 read-only list tool with an output schema, annotations covering safety, and fully documented parameters, the description covers the essential content (priority order, story points, epics). It is adequate for an agent to call it correctly, though it could mention it returns tasks or list, but that is implied.

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 (group_id, max_tasks) are fully documented in the schema (100% coverage). The description adds no additional semantic meaning about parameters beyond what the schema already provides.

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

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

The description states the resource (scrum backlog) and its organization (priority order) and content (story points, epics). It is specific enough to distinguish from sibling tools like scrum_sprints or sprint_board, though it lacks an explicit verb like 'list' or 'get'.

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

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

No guidance on when to use this tool versus alternatives like scrum_sprints or tasks_list. The description does not mention any conditions, exclusions, or alternative tools.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the ordering behavior ('from new to old'), which is useful context, but it does not disclose pagination, result scope, or filtering behavior beyond what the schema already 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?

The text is very short and contains no filler, but it is under-specified: it conveys a resource and ordering but omits the actual operation. This is economy at the expense of clarity, not well-structured 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 only two parameters, one required, and an output schema present, the tool is relatively simple. However, the ambiguous purpose and lack of sibling differentiation leave gaps that a few additional words about listing sprints versus backlog or board would easily fill.

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%: group_id is explained as 'ID проекта, группы или скрама (из projects_list)' and status has enum descriptions. The tool description adds no extra parameter meaning, so it neither improves nor harms the schema's baseline.

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

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

The description is a noun phrase ('Scrum sprints, from new to old') with no explicit verb such as 'list' or 'return', so the agent must infer the action from the tool name. It identifies a resource but does not distinguish this tool from siblings like scrum_backlog or sprint_board.

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 about when to use this tool versus alternatives such as scrum_backlog, sprint_board, or tasks_list. There are no preconditions, exclusions, or routing hints.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds that the result includes stages, tasks, story points, and epics, but it does not disclose behavior such as defaulting to the active sprint or how empty stages are handled.

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 with no filler or redundancy. Every word contributes to identifying the resource and its contents.

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 board tool with fully documented optional parameters and an output schema, the description captures the essential return concept. It could be more complete with a brief routing note against similar siblings, but that gap is already reflected in usage_guidelines.

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 already documented in the input schema. The description adds no parameter-level meaning, so the baseline score of 3 is appropriate.

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

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

The description names the resource (sprint kanban) and its contents (stages, tasks, story points, epics), so an agent can infer this returns a board view of a sprint. It lacks an explicit verb and does not explicitly distinguish it from sibling board/backlog tools like scrum_backlog or project_board.

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 provided on when to use sprint_board versus scrum_sprints, scrum_backlog, project_board, or tasks_list. The description only states what the board contains, leaving tool selection entirely 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?

The description adds meaningful behavioral context beyond the annotations: it explicitly states that user confirmation is required ('Требует подтверждения пользователя'), which is a critical interaction requirement not visible in the schema or annotations. The annotations already indicate this is a mutating operation (readOnlyHint=false) and not destructive (destructiveHint=false), and the description aligns with those. The idempotentHint=true annotation is not contradicted by the description, though the description doesn't elaborate on idempotency behavior.

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

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

The description is a single, compact sentence that conveys the core action, the source of stage IDs, and the confirmation requirement. Every element earns its place, and the most important information (what the tool does) 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?

The description is complete for a mutating operation with a well-defined schema and output schema. It covers the action, the parameter source, and the confirmation requirement. The main gap is the lack of explicit differentiation from task_move_stage, which is a sibling tool that appears to serve a similar purpose. Given the tool's moderate complexity and the presence of an output schema, this is a minor omission.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters with descriptions. The description adds the key semantic detail that stage_id values come from sprint_board, which helps the agent understand the parameter's source. However, it doesn't add detail about task_id or sprint_id beyond what the schema provides, so the added value is modest.

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 ('Перенести' = move) and resource ('задачу на другую стадию канбана спринта' = task to another sprint kanban stage), which clearly distinguishes it from generic task operations. It also references sprint_board for stage IDs, adding useful context. However, it doesn't explicitly differentiate from the sibling task_move_stage, which appears to be a closely related 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?

The description implies usage context by mentioning that stage IDs come from sprint_board, which tells the agent where to find a required parameter. It also notes that user confirmation is required, which is a usage constraint. However, it doesn't explicitly state when to use this tool versus task_move_stage or other task-related tools, leaving the selection logic partially to inference.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the agent knows this is a non-destructive write. The description adds valuable behavioral context: it requires user confirmation ('Требует подтверждения пользователя') and notes the destination behavior difference on old portals. This goes beyond the annotations and helps the agent anticipate an interactive confirmation step.

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, no wasted words. The core action is front-loaded, and the confirmation requirement is stated clearly. Every sentence earns its place.

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

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

For a simple two-parameter tool with a full output schema and annotations covering the safety profile, the description is nearly complete. It covers the action, destination, and the confirmation requirement. The only minor gap is not explicitly routing away from crm_add_comment, but the sibling list and tool name make that distinction reasonably clear.

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 (id and text). The description adds no additional parameter-level meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb ('написать' = write) and resource ('комментарий к задаче' = comment to a task), and clarifies the destination (task chat or comments on old portals). It is clear, though it doesn't explicitly distinguish it from the sibling crm_add_comment, which is for CRM entities rather than tasks.

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

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

The description implies when to use it: when you need to add a comment to a task. It does not explicitly state when not to use it or mention alternatives like crm_add_comment for CRM objects. The context signals and sibling list provide some differentiation, but the description itself lacks explicit routing guidance.

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

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

The annotations already provide readOnlyHint=true and openWorldHint=true, so the safety profile is covered. However, the description adds no behavioral context beyond a label; it does not mention scoping, limitations, or any behavior not already captured by annotations. No contradiction exists, but there is no added transparency.

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

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

The definition is extremely short with zero redundancy, making it structurally efficient. However, the brevity borders on under-specification rather than crafted conciseness, so it does not earn a 5.

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

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

Given one parameter, full schema coverage, an existing output schema, and readOnly/openWorld annotations, the terse description is nearly adequate. Still, it lacks an explicit verb or statement of operation, leaving an agent to infer that this tool retrieves task checklist items.

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 'id' has full schema description coverage (100%), including 'ID задачи' (task ID). The tool description adds no additional semantic detail about the parameter, so the baseline of 3 is appropriate.

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

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

The description 'Пункты чек-листа задачи' ('Task checklist items') is a noun phrase that essentially restates the tool name 'task_checklist' rather than stating a specific action. It does not clearly say whether the tool lists, retrieves, or manages checklist items, and it fails to differentiate from siblings like task_checklist_add or task_checklist_complete.

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

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

There is no guidance about when to use this tool versus alternatives such as task_checklist_add or task_checklist_complete. The only implied context is the required 'id' parameter, but the description itself provides no usage direction.

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

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

Beyond the annotations, the description discloses that this mutation requires user confirmation, adding valuable behavioral context. It does not detail side effects, but with readOnlyHint=false and destructiveHint=false already covering the safety profile, this is sufficient.

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 short sentences with no filler. The core action is front-loaded and the confirmation requirement is stated immediately after.

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

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

For a simple two-parameter mutation with annotations and an output schema present, the description covers the essential context. The confirmation requirement is the key operational detail and it is included.

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 adequately. The description adds no additional parameter-level detail, meeting the baseline but not exceeding it.

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

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

The description states a specific action, 'add an item to a task checklist,' which clearly identifies the resource and operation. It is easily distinguished from sibling tools like task_checklist_complete and task_checklist.

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 notes that user confirmation is required before use, which is an important usage condition. It does not explicitly name alternatives or exclusion cases, but the context is clear enough.

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

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

Annotations already cover readOnlyHint=false and destructiveHint=true. The description adds the requirement for user confirmation, which is extra behavioral context not captured by annotations. It also implicitly indicates a state change. This adds value beyond the annotations, though it does not detail side effects or reversibility.

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 with no fluff. The main action is front-loaded, and the confirmation requirement is stated succinctly. Every word earns its place.

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

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

For a simple two-parameter mutation tool with an output schema present, the description is adequate. It covers the action and the confirmation requirement. It could mention prerequisites like the item existing, but that is not critical for basic usage. Given the annotations and schema, the description is fairly complete.

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

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

Schema description coverage is 100%, with both id and item_id clearly documented. The description does not add any parameter-level detail beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states the specific verb 'Отметить' (mark), the resource 'пункт чек-листа' (checklist item), and the outcome 'выполненным' (completed). This distinguishes it from sibling tools like task_checklist_add (which adds items) and task_complete (which completes entire tasks).

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 mentions that user confirmation is required, which gives some context, but it does not explicitly state when to use this tool versus alternatives or provide exclusion criteria. The implication is clear from the resource type, but no explicit routing to alternatives is 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the mutating nature is covered. The description adds useful behavioral context by requiring user confirmation, but it does not describe side effects, reversibility, or any consequences beyond completing the task.

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

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

The description is extremely concise: two short sentences. The primary action is front-loaded, and the confirmation requirement is stated immediately after. Every word earns its place.

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

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

For a simple single-parameter tool with an output schema and annotations covering destructiveness and read-only status, the description is nearly complete. It adds the important user-confirmation requirement but omits any context about when completing a task is appropriate or what happens after completion.

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 only parameter, 'id' (task ID). The description does not add meaning beyond the schema, so it meets the baseline for high coverage without enriching parameter understanding.

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: 'Завершить задачу' (complete the task). It is clear enough to distinguish from siblings like task_delete or task_update, though it does not explicitly name the alternative it is not.

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 a prerequisite, 'Требует подтверждения пользователя' (requires user confirmation), but gives no guidance on when to use this tool versus alternatives such as task_move_stage or task_update. No exclusions or alternative conditions are 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 already indicate readOnlyHint=false and destructiveHint=false, so the description adds value by disclosing that user confirmation is required—a behavioral constraint not present in the annotations. This helps the agent know it must pause for user approval before executing.

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 short sentences with no redundant phrasing. It front-loads the action, then covers mandatory fields and confirmation in a compact, efficient manner.

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 creation tool with a complex nested fields object, the description covers the essential prerequisites and constraints. An output schema exists, so return-value details are not required. It could mention error conditions or permission requirements, but it is sufficiently complete for an agent to call it correctly.

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

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

The schema provides detailed coverage of the fields object, but the description adds critical semantic meaning: it marks TITLE and RESPONSIBLE_ID as mandatory inside the fields object (not enforced by the schema's required array) and directs the agent to users_search for finding RESPONSIBLE_ID. This goes beyond the schema's documentation.

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

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

Description states a clear verb and resource ('Создать задачу' = Create a task) and is distinct from sibling tools like task_update, task_delete, and task_get. It immediately clarifies the action and what is being acted upon.

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 practical usage guidance: it lists mandatory fields (TITLE and RESPONSIBLE_ID), points to users_search for finding IDs, and notes that user confirmation is required. While it does not explicitly name alternative tools for other operations, the purpose is unambiguous enough for an agent to select it for creation tasks.

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

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

Annotations already declare destructiveHint=true, so the destructive nature is known. The description adds value beyond annotations by explicitly requiring user confirmation, which is a meaningful behavioral constraint for an AI agent invoking a destructive operation. 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 extremely concise and front-loaded: the action 'Удалить задачу' appears first, followed by the only essential behavioral note. There is no filler 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?

For a simple one-parameter delete operation, the description plus annotations are nearly sufficient: it names the resource, requires user confirmation, and the schema covers parameters. A slightly richer mention of irreversibility or cascading effects would make it fully complete, but the confirmation requirement already covers the main risk.

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 fully documents the single required parameter 'id' with a clear description. The tool description adds no extra parameter-level detail, which is acceptable given 100% 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 states a specific verb ('Удалить' / delete) and a clear resource ('задачу' / task). This makes the tool's purpose unambiguous and naturally distinguishes it from siblings like task_get, task_update, task_complete, and crm_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 phrase 'Требует подтверждения пользователя' provides an important usage precondition: the agent should not invoke this tool without user confirmation. However, it does not explicitly compare this tool to alternatives or state when to prefer task_delete over task_update or task_complete.

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 readOnlyHint and openWorldHint. The description adds a small behavioral detail by stating the response contains all filled fields including description, which is useful but minimal. 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?

A single sentence with a clear verb and object, no filler. The key qualifier 'all filled fields, including description' is front-loaded and earns its place.

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

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

Given the output schema covers return structure and annotations cover safety, the description is almost complete for a simple get-by-id operation. The only minor gap is the lack of explicit sibling differentiation, which is not critical here.

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

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

The input schema fully documents the only parameter 'id' with a description, so schema coverage is 100%. The tool description does not add parameter-specific semantics beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description clearly states the verb 'Получить' (get) and the resource 'задачу' (task), and specifies that all filled fields including description are returned. This distinguishes it from listing tools like tasks_list, though it does not explicitly name 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 guidance on when to use this tool versus alternatives such as tasks_list or task_update. The single-id parameter implies retrieving one task, but no exclusions, prerequisites, or alternative conditions are described.

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=false and destructiveHint=false; the description adds a meaningful behavioral trait beyond them: 'Требует подтверждения пользователя' (requires user confirmation). It doesn't detail permissions or side effects, but with annotations carrying the safety profile this is sufficient context.

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

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

Three short sentences, each earning its place: purpose, sibling routing, and confirmation requirement. The most important differentiating information is front-loaded and there is no redundant text.

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 2-parameter mutation with an output schema and helpful annotations, the description covers purpose, stage-ID sourcing, sibling routing, and confirmation. It could be slightly more explicit about how confirmation should be obtained or what happens if the stage belongs to another project, but these are minor 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?

The schema already fully documents both parameters (id, stage_id) with descriptions. The description adds value by telling the agent where to find valid stage IDs ('ID стадий — в project_board') and clarifying that stage_id is the kanban stage, which goes beyond the raw 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?

Description opens with a specific verb and resource: 'Перенести задачу проекта на другую стадию канбана' (move a project task to another kanban stage). It also differentiates from the closest sibling by naming sprint_move_task for scrum tasks, so an agent can disambiguate tool purpose immediately.

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 says 'Для задач скрама используйте sprint_move_task' (use sprint_move_task for scrum tasks), which is a direct when-not/when-to-use-alternative. It also flags that the operation requires user confirmation, a key precondition for invoking the tool.

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

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

Annotations already declare readOnlyHint=true, covering the safety profile. The description adds one useful behavioral note, 'Поля в ответе в camelCase', but doesn't elaborate on pagination, defaults, or other runtime behavior beyond what the schema already states.

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 filler: the purpose is front-loaded and the camelCase note is a meaningful second sentence. Nothing repetitive.

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 rich schema (limit, order, start, filter, select), output schema, and annotations cover most operational details. The only notable gap is usage guidance for choosing this over sibling task tools, but nothing needed to make a correct call 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%, with detailed parameter docs including filter syntax, status semantics, defaults, and field selection. The description itself adds no parameter meaning, 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 starts with 'Найти задачи по фильтру' – a specific verb ('find'), resource ('tasks'), and scoping mechanism ('by filter'). This is clear, though it doesn't explicitly differentiate from task_get or other task_* siblings beyond the filter wording.

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

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

No when-to-use vs alternatives guidance: it never mentions task_get for singular lookups or when this list is appropriate versus other list tools. The filter phrase implies a use case, but there are no exclusions or sibling routing instructions.

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

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

The description discloses that 'Требует подтверждения пользователя' (requires user confirmation), which is not covered by the annotations (readOnlyHint=false, destructiveHint=true, openWorldHint=true). This adds an important behavioral detail about the interaction flow, complementing the destructive hint without contradicting it.

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

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

A single, concise sentence that front-loads the action and the key constraint. No filler words; every element contributes to the meaning.

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

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

For a straightforward update tool, the description covers the action, the partial-update rule, and the confirmation requirement. An output schema exists to document return values, so the description does not need to explain them. It could mention error cases or prerequisites, but those are not essential for a typical update call.

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

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

Schema description coverage is 100%, so the 'fields' object is thoroughly documented with allowed field names and formats. The description's note about only sending changed fields is a usage guideline rather than new parameter semantics. Thus, the description adds minimal value beyond the schema, warranting the baseline score.

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

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

The description clearly states the tool's purpose with a specific verb ('Изменить' – to change) and resource ('задачу' – task), making it obvious this updates an existing task. It is distinct from siblings like task_create, task_delete, and task_complete, so an agent can differentiate at a glance.

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 instruction 'Передавайте только изменяемые поля' (pass only the fields to be changed) provides clear guidance on how to use partial updates. It does not explicitly name alternatives or say when not to use it, but the context implies it is for editing an existing task, which is sufficient for most 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description adds the contextual detail that the user is the webhook's acting identity. It does not disclose return format or additional behavior, but given the read-only annotation, the description's contribution is modest yet non-contradictory.

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

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

The description is a single, short sentence that is efficiently front-loaded with the core purpose. It is concise and contains no filler, though it could be slightly more explicit with a verb phrase.

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

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

For a zero-parameter, read-only tool with an output schema (as indicated), the description is sufficient. It clarifies the operational context (webhook) and the return value. The output schema presumably details the return structure, so the description does not need to elaborate further.

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

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

With zero parameters and 100% schema coverage, the description does not need to elaborate on parameters. The baseline for no-parameter tools is 4, and the description appropriately avoids redundant parameter information.

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

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

The description states the tool returns the user on whose behalf the webhook operates, which clearly identifies the resource and purpose. It is a noun phrase rather than a verb+resource construction, but the meaning is unambiguous and distinct from siblings, as no other tool references the current user.

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

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

The description implies usage when the agent needs to know the executing user of a webhook, but does not explicitly state when to use it versus alternatives or provide exclusions. There are no similar sibling tools, so context is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the read-only nature is covered. The description adds the behavioral nuance that only active employees are returned, which is useful beyond the annotations. No contradictions found.

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-front-loaded sentence that states the action, scope, and an example purpose. No filler or redundant content.

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

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

For a simple one-parameter search tool with a read-only annotation and an output schema present, the description is complete. It tells the agent what to search, who is returned, and why you would use 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% and the single 'query' parameter is already described as 'Имя, фамилия, должность или отдел'. The description adds a use-case example but no additional parameter semantics, 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?

Description states a specific verb and resource: 'Найти активных сотрудников портала' (find active portal employees), with a concrete use case of retrieving a responsible person's ID. This clearly differentiates it from sibling tools like user_current and crm tools.

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

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

The description gives a clear context ('active employees') and a concrete example ('to find out the ID of the responsible person'), which implies when to use it. It does not explicitly name alternatives or exclusions, but the purpose is specific enough for basic routing.

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