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

With no annotations, the description bears full responsibility for disclosing behavior. It simply states 'call directly' without mentioning error handling, authentication requirements, rate limits, return value format, or side effects. This leaves the agent uncertain about what to expect when invoking arbitrary methods.

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 sentence with no wasted words, directly stating the tool's core function. It is front-loaded and efficiently communicates the essential purpose, making it excellent from a conciseness standpoint.

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

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

For a generic raw API wrapper with no annotations, no output schema, and many sibling tools, the one-line description is insufficient. It fails to explain when to use this tool, what kind of response to expect, or any operational constraints, leaving significant gaps in the agent's ability to decide and invoke correctly.

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

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

The input schema fully documents both parameters with examples and descriptions (100% coverage), so the tool description adds nothing beyond the schema. Per the rubric, a baseline of 3 is appropriate when schema coverage is high, even though the description itself contributes no parameter-specific meaning.

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

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

The description clearly states the tool calls any Bitrix24 REST API method directly, with a specific verb and resource scope. It implies differentiation from sibling tools by being a generic raw API access, but it doesn't explicitly name alternatives or detail when the specialized tools should be preferred.

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 this tool versus the many specialized sibling tools. The phrase 'directly' suggests using it as a fallback, but there is no explicit mention of preferring dedicated tools when available, nor any context for when this is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action without any detail on side effects, conflict handling, permissions, or return values. The generate_unique_name parameter hints at conflict behavior, but the description itself adds no behavioral context.

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

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

The description is a single sentence, front-loaded with the primary purpose, and free of unnecessary words. It is concise and well-structured.

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

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

With 5 parameters, no output schema, and no annotations, the description provides only the core action. It omits crucial context such as return value, prerequisite conditions, or behavior when conflicting parameters are provided. The schema covers parameter details but does not compensate for missing overall behavioral context.

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

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

Schema description coverage is 100%, and each parameter already has a detailed description. The tool description's mention of 'local path or base64' is redundant with the schema's mutual exclusivity note. Thus, the description adds no meaningful parameter semantics beyond the schema, earning the baseline score of 3.

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

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

The description clearly states the verb 'Загрузить' (upload), the resource 'Bitrix Drive', and the scope (from local path or base64 content). This distinguishes it from sibling upload tools like im_send_file or task_attach_file, which target different resources.

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

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

The description clearly implies the tool is for uploading files to Bitrix Drive from either a local path or base64 content. It does not explicitly mention alternatives or exclusions, but the context is unambiguous. A 5 would require explicit when/when-not guidance, which is absent.

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

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

No annotations are provided, so the description carries the full burden. It discloses that chats are filtered by current user availability, but does not mention read-only nature, pagination behavior, or any other side effects. The description is too sparse to convey meaningful behavioral traits beyond the basic scope.

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, clear sentence that conveys the core purpose without extra words. It is front-loaded and efficient, making it easy for an agent to parse quickly.

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 search tool with well-documented parameters, the description is minimally viable. However, it lacks usage guidelines and does not mention return format (since no output schema exists). The presence of sibling tools like im_chat_list creates potential confusion that the description does not resolve.

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

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

The input schema has 100% coverage with descriptions for all three parameters (query, limit, offset). The description only adds that searching is by name, which is already implied by the 'query' parameter description ('Строка поиска'). It does not add significant value beyond the schema.

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

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

The description clearly states the tool finds chats available to the current user by name/title, using a specific verb (find) and resource (chats). It implies search functionality, distinguishing it from listing tools like im_chat_list, though it does not explicitly name alternatives.

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 no explicit guidance on when to use this tool versus alternatives such as im_chat_list. The only context is the implied use case of searching by name, which is embedded in the purpose rather than as a distinct usage guideline.

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

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

With no annotations, the description carries the behavioral burden. It adds useful context by indicating the result is scoped to the current user and limited to 'recent' chats/channels. It does not, however, describe sorting, pagination details beyond the limit parameter, or the exact response shape, leaving some gaps.

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 front-loads the main purpose. Every part is useful and there is no redundant or filler 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 list tool with one documented optional parameter and no output schema, the description is adequately complete. It defines the scope (current user, recent) and the content (chats/channels). It could be slightly more detailed about return structure, but given the low complexity it does not need much more.

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

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

The schema already fully describes the single parameter 'limit' with its default value, so the description does not need to add parameter details. The description adds no extra parameter semantics beyond what the schema provides, 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 the action (list) and the resource (recent chats/channels of the current user). It distinguishes itself from sibling tools like im_chat_messages (messages in a chat) and im_chat_find (search for chats) by explicitly scoping to a list of the user's chats/channels.

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

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

Usage is implied: this tool should be used to get the current user's recent chats/channels. However, it does not explicitly mention when to prefer this over related tools such as im_chat_find or workgroup_chat_get, nor does it state exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the burden. It discloses one behavioral trait (adding thread for available threads), which adds value beyond the schema. However, it does not elaborate on pagination behavior, default sorting, or return format, leaving gaps in 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 description is a single, concise sentence that conveys the core function and a notable feature. However, the phrase 'для доступных тредов добавляет thread' is a bit ambiguous and could be clearer, slightly reducing the score.

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

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

With no output schema, the description does not explain the return structure, but it does cover supported dialog types and the thread feature. Given the tool's moderate complexity, the description is adequate but leaves room for more detail on the thread behavior and message retrieval specifics.

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

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

Schema description coverage is 100%, with clear explanations for limit, first_id, and dialog_id (including examples). The description itself adds little beyond what the schema already 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 tool retrieves messages from chats, channels, or personal dialogs, using a specific verb ('Получить') and resource ('сообщения'). It also mentions the thread-adding behavior, which helps distinguish it from plain message retrieval tools, though the concept of 'thread' is not fully explained.

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 provide explicit guidance on when to use this tool versus alternatives like im_thread_messages or tasks_chat_messages. The only hint is the mention of thread addition, but no direct comparison or exclusion criteria are given.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It discloses that the tool paginates through im.dialog.messages.get via FIRST_ID, and the schema includes max_pages with description 'Protection against long chats.' This reveals the iterative fetching behavior. However, it does not explain the return structure, error handling, or rate limits, which could be relevant for such a read operation.

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

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

The description is a single, concise sentence that front-loads the primary purpose and then adds the key implementation detail (pagination via FIRST_ID). Every word contributes value, with no 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?

Given the tool's complexity (6 parameters, no output schema, no annotations), the description provides a clear operational summary: purpose, date range, and pagination strategy. The schema covers parameter details. It lacks explicit return format details, but this is likely consistent with sibling message tools. It could be improved by noting the order of messages or timezone handling, but overall it is reasonably complete.

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

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

The input schema provides detailed descriptions for all 6 parameters (100% coverage), so the baseline is 3. The description adds context about the paging mechanism (FIRST_ID) that relates to page_limit and max_pages, but this is already partially implicit in the schema descriptions. It does not significantly enhance understanding of individual parameters beyond what the schema provides.

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

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

The description clearly states the tool's function: 'Get dialog messages for a date range' (Получить сообщения диалога за диапазон дат). It also specifies the implementation method ('paging through im.dialog.messages.get via FIRST_ID'), which distinguishes it from sibling tools like im_chat_messages (likely for all messages) and im_thread_messages.

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: when a date range is needed, and indicates the underlying API method for pagination. However, it does not explicitly mention alternatives or exclusions, such as 'use im_chat_messages for unfiltered retrieval' or 'not for thread messages.' The context is clear but lacks explicit when-not-to-use guidance.

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

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

No annotations are provided, and the description only states the action without disclosing the scanning behavior implied by parameters like scan_limit, scan_forward, and scan_start_chat_id. The agent is unaware that finding the comment chat may require scanning up to 5000 chat IDs, which is a significant behavioral trait.

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, clear sentence with no redundancy. However, it lacks additional structure or sub-sections to convey scanning behavior, though it is appropriately concise for the purpose statement.

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

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

The description is inadequate for a tool with 9 parameters and a complex scanning mechanism. Without an output schema or annotations, the agent lacks information about return format, failure modes, and the search behavior, making it hard to invoke correctly in unexpected scenarios.

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 covers 100% of the parameters with detailed descriptions, so the description adds little beyond the context of a 'hidden comment-chat'. This meets the baseline for schema-covered parameters.

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

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

The description uses the specific verb 'get' and clearly identifies the resource: comments on a channel publication from a hidden comment chat. This distinguishes the tool from siblings like im_thread_messages or im_chat_messages which target regular chats or threads.

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

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

No explicit guidance on when to use this tool vs alternatives. The description does not mention exclusions or prerequisites, leaving the agent to infer the use case solely from the tool name and schema. With overlapping siblings like im_thread_messages, this is a gap.

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?

There are no annotations, so the description carries the full burden. It states the primary behavior (send file to chat/private dialog) and lists the three input paths, but does not disclose potential side effects, permission requirements, or what happens when conflicting parameters are provided. 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?

The description is a single, front-loaded sentence that conveys the tool's purpose and key input options without any filler. It is concise and every word contributes meaning.

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

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

With 6 parameters, no annotations, and no output schema, the tool is moderately complex. The schema covers parameters well, but the description lacks guidance on when to use this versus sibling tools and does not describe the result of the operation. It is sufficient for basic invocation but leaves 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%, with each parameter individually documented. The description adds a high-level grouping of input modes (local_path/content_base64 vs file_id), but this is already reflected in the schema's file_id description. The description provides no additional value beyond the structured schema.

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

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

The description uses a specific verb 'Отправить' (send) with a clear resource 'файл в чат/личный диалог' (file to chat/private dialog), and further specifies three input modes (local path, base64, existing file_id). This clearly distinguishes it from sibling tools like im_send_message (sends text) and disk_upload (uploads to drive).

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 sending files into chat contexts, but it does not explicitly state when to prefer this over sibling tools such as disk_upload, im_send_message, or task_attach_file. There are no exclusions or alternative recommendations, so usage context is only implied.

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

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

There are no annotations, so the description carries full burden of behavioral disclosure. It only states the basic sending action, without mentioning message length limits, formatting, permissions, side effects, or whether this creates a new message.

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 one concise sentence with no unnecessary words. It is front-loaded with the core action and easily scannable for 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?

The tool is simple with no annotations or output schema, but the description lacks usage context and behavioral details. Given sibling tools like im_send_file and im_thread_reply, more guidance would be needed to fully contextualize this tool.

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

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

The schema descriptions fully document both parameters, including a format example for dialog_id. The tool description adds no additional parameter-level meaning, so it meets the baseline for high schema coverage but does not exceed 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 clearly states the tool sends a message to a chat or personal dialogue, using a specific verb (send) and resource (message). It implicitly distinguishes from siblings like im_send_file (file vs message) and im_chat_messages (read vs send), covering the full scope.

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

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

No guidance is provided on when to use this tool versus alternatives. The description simply states the action without any exclusions, prerequisites, or mention of sibling tools for different contexts.

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

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

With no annotations provided, the description carries the full burden. It discloses two critical behaviors: the operation is READ-ONLY and it uses fallback scanning when im.v2 is unavailable. This gives the agent a clear safety profile and an understanding of the underlying behavior, though it omits details like authentication or rate limits.

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

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

The description is a single, front-loaded sentence that immediately communicates the READ-ONLY nature and the core function. It is concise with no filler, and every phrase adds value.

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

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

The tool has six parameters and no output schema, yet the description does not mention return format, pagination behavior, or how the limit and scan_pages parameters affect results. The fallback scanning note adds useful context, but overall the description is sparse for a tool of this complexity, leaving some 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 input schema already provides 100% description coverage for all six parameters, so the baseline is 3. The description itself adds no additional parameter semantics beyond the schema, not even connecting the fallback behavior to scan_pages or thread_dialog_id.

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 a specific action ('read existing thread (comments) of a channel message') with an explicit READ-ONLY marker. This distinguishes it from write/reply tools like im_thread_reply and im_chat_messages, 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 implies the tool is for reading existing threads but does not explicitly state when to prefer it over similar read tools like im_message_comments or how to handle fallback scenarios. No exclusions or alternatives are named, so usage 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?

Since no annotations are provided, the description carries the full burden of disclosing behavioral traits. It reveals that the message is sent on behalf of the webhook owner and that thread creation is unsupported, which are key side effects. It does not cover error behavior or notifications, but for a simple write operation, this is reasonable disclosure.

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

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

The description is a single, front-loaded sentence with a clear 'WRITE:' label that signals the operation type. It is concise, contains no filler, and effectively communicates the core action and constraint in minimal space.

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 moderate complexity with four parameters, but the schema documents them well, and the description captures essential context: it is a write operation for existing threads on behalf of the webhook owner. The absence of an output schema is acceptable because the description focuses on the action and constraints. A minor gap is that it does not clarify behavior when parameter combinations conflict, but this is not critical.

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 provides descriptions for all four parameters, achieving 100% coverage, so the tool description does not need to add extra parameter details. The description itself omits any mention of parameters, but the schema already offers clear semantics for dialog_id, message_id, and thread_dialog_id. This aligns with the baseline of 3 for high schema coverage.

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

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

The description clearly states the tool sends a message to an existing thread on behalf of the webhook owner, using a specific verb and target. The 'WRITE:' prefix and the explicit note that new threads are not created via REST distinguish it from read-oriented tools like im_thread_messages or im_chat_messages.

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 limits usage to existing threads, stating that new threads cannot be created via REST, which gives a clear boundary. However, it does not name alternative tools for sending new messages (e.g., im_send_message), so only implied differentiation from siblings is provided.

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

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

With no annotations provided, the description carries the full burden. It discloses the required scope, the return contents (title, Markdown, metadata), and the ID source from the URL. It does not mention potential errors or rate limits, but for a simple retrieval this is adequate.

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

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

The description is three short, purposeful sentences. It front-loads the core purpose, then adds the ID source and auth requirement. No unnecessary words or repetition.

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

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

The description fully answers what the tool does, what it returns, how to determine the ID, and what auth is needed. Given the simple one-parameter schema and absence of an output schema, this is complete enough for an agent to use correctly.

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

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

The schema already documents the 'id' parameter with an example. The description adds meaningful extra context by explaining that the ID is the number from the /note/document/<id>/ URL, which helps the agent correctly construct the parameter value.

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

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

The description clearly identifies the tool as fetching a knowledge base document by ID, including title, Markdown, and metadata. This distinguishes it from sibling tools like kb2_document_create/update/delete and kb2_search, which serve different purposes.

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

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

The description states that the ID comes from the URL /note/document/<id>/ and that the 'note' scope is required. This provides clear context for when to use the tool, though it does not explicitly mention exclusions or alternatives.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses the write nature, the two-phase confirmation requirement to prevent accidental creation, and the webhook permission dependency. This is substantive behavioral context beyond a simple 'creates a document', though it does not describe the exact response or error behavior.

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

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

The description is only two sentences long, with the critical 'WRITE' keyword front-loaded. Every clause earns its place: what it does, the confirm=false→preview→confirm=true flow, and the permission caveat. There is no verbose 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?

Given 7 parameters and no output schema, the description adequately covers the essential operational context: the confirmation protocol and permission requirements. It does not detail the shape or contents of the preview response or error conditions, but the rich schema compensates for parameter-level gaps. This is a solid, usable description.

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

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

The input schema already covers 100% of parameters with detailed descriptions, so the baseline is 3. The description adds extra meaning to the confirm and expected_preview_key parameters by explaining their workflow relationship (first call returns preview, second call requires matching preview_key). This exceeds 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 opens with 'WRITE' and explicitly states the action: 'создать документ Базы знаний 2.0' (create a Knowledge Base 2.0 document) via note.document.add. This clearly identifies a create operation on a specific resource and naturally distinguishes it from sibling tools like kb2_document_update or kb2_document_delete.

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

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

The description gives explicit usage workflow: call with confirm=false first and show the preview to the user, then pass confirm=true only after explicit user confirmation. It also states the permission prerequisite. However, it does not explicitly contrast with alternative tools (e.g., when to use update instead of create), so it stops short of a 5.

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

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

No annotations are provided, so the description carries full burden. It clearly discloses the destructive nature (move to trash), the mandatory confirmation flow, the expected-value matching to prevent stale deletions, and the permission requirement. This goes well beyond a simple 'delete' statement.

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 four sentences, front-loaded with the core purpose ('WRITE: move to trash'). Each sentence conveys essential information: operation, preview step, confirmation constraint, and permission caveat. No fluff or repetition that isn't load-bearing.

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

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

For a destructive delete tool with no output schema, the description sufficiently covers the full flow: preview, confirmation, expected values, and permission. It mentions the preview return data (expected_title, expected_updated_at), making return behavior understandable. The context of children handling is in the schema, so description need not repeat 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 coverage is 100% and parameters are already well described in the schema. The description adds value by explaining the two-phase workflow (confirm=false preview then confirm=true) and tying expected_title/expected_updated_at to the preview response, which is not fully captured by individual parameter descriptions.

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

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

The description explicitly states 'move a Knowledge Base 2.0 document to trash' (переместить документ Базы знаний 2.0 в корзину), using a specific verb and resource. It is clearly distinguished from sibling tools like kb2_document_create and kb2_document_update, as deletion is a distinct operation.

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

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

The description provides explicit step-by-step usage guidance: first call with confirm=false to obtain and show a preview, then only pass confirm=true after explicit user confirmation in the current dialog with matching expected_title and expected_updated_at. It also notes the webhook deletion right requirement, making when-to-use and prerequisites unambiguous.

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

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

With no annotations provided, the description carries the full burden and covers key behavioral traits: the write nature, two-phase confirmation, optimistic concurrency via updatedAt check, prohibition on agent self-confirmation, forced overwrite=false, and required scope/permissions. This is rich, actionable context beyond the schema.

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

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

The description is a tight paragraph where each sentence adds value: the WRITE prefix, the update scope, the preview/confirm workflow, concurrency handling, and permissions. No redundancy or fluff, despite covering a complex interaction.

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

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

For a mutation tool with no annotations and no output schema, the description provides a complete picture: what it does, how to use it correctly, what security/permissions are required, and how stale updates are prevented. The sibling context (update vs create/delete) is 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 covers all parameters at 100%, but the description adds crucial semantics for confirm and expected_updated_at: the preview workflow, that confirm=true requires the same expected_updated_at, and that MCP re-checks updatedAt. This goes beyond the schema's static descriptions.

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

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

The description opens with 'WRITE: обновить заголовок и/или Markdown документа Базы знаний 2.0', which clearly states the action (update) and resource (KB 2.0 document title/Markdown). This distinguishes it from sibling tools like create and delete.

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

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

The description gives explicit workflow guidance: first call with confirm=false, save expected_updated_at, then after user confirmation call with confirm=true. It also instructs the agent not to self-confirm. However, it does not explicitly mention alternatives or when not to use the tool beyond the confirmation flow.

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

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

With no annotations provided, the description carries the burden of behavioral context. It adds useful information about API version and required permissions, but does not explicitly state that this is a read-only operation or describe the return behavior such as pagination or sorting.

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 information. The first sentence delivers the core purpose, and the second adds necessary technical requirements. 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 zero-parameter list tool with no output schema, the description covers the essential aspects: what is returned (available KBs) and under what conditions it can be called. It lacks information about the format or fields of the returned items, but this is a minor gap given the tool's simplicity.

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

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

The tool has zero parameters, so the description does not need to explain them. Per the baseline for 0-param tools, a score of 4 is appropriate. The description does not add parameter-specific detail because there are none.

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

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

The description states the resource ('knowledge bases 2.0') and implies the action (listing available ones), making it clear it retrieves a list of KBs the user can access. It distinguishes from siblings like kb2_search and kb2_document by scope, but does not use an explicit verb like 'list' or 'returns'.

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

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

It provides prerequisites (REST 3.0, webhook scope 'note', user permission) that indicate when the tool can be used, but does not explicitly mention alternatives or when not to use it. Sibling tools like kb_list and kb2_search exist, but the description does not contrast with them.

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

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

With no annotations, the description carries the full burden. It discloses pagination behavior (first page only, hasMore flag) and the auth scope 'note', which are important operational details. It does not mention return format or explicitly state read-only behavior, but search semantics imply no mutation.

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

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

Three concise Russian sentences, each delivering distinct information: purpose, pagination caveat, and scope requirement. No filler or 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 search tool with full schema coverage and no output schema, the description covers purpose, search fields, pagination, and auth. It lacks return format and error handling details, but these are less critical for a search operation. The guidance to 'refine the query' when hasMore=true is somewhat vague but acceptable.

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

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

The input schema already covers both parameters with descriptions, so baseline is 3. The description adds meaning by specifying that the query searches by title and content and that limit pertains to the first page size, going beyond the schema's generic wording.

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

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

The description clearly states the tool's function: 'Поиск документов базы знаний 2.0 по заголовку и содержимому' (Search of knowledge base 2.0 documents by title and content). This provides a specific verb, resource, and scope, and the '2.0' label distinguishes it from sibling tools like kb_search and kb2_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 gives practical context: it searches KB 2.0 by title/content, warns that Bitrix24 returns only the first page, advises refining the query when hasMore=true, and specifies the required scope 'note'. It does not explicitly name alternative tools, but the '2.0' designation and search fields imply the intended use case.

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

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

With no annotations, the description carries the full burden and does well by explaining the meaning of the truncated=true field and the required 'note' scope. This adds valuable behavioral context beyond what the schema provides, though it does not mention potential pagination or error cases.

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, information-dense sentences: purpose, truncation behavior, and scope requirement. No wasted words; every clause adds value.

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

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

For a tool with a single well-described parameter and no output schema, the description covers the essential aspects: what the tool returns, a critical field's meaning, and an access requirement. It is reasonably complete, though it could mention the return format structure slightly more explicitly.

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

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

The sole parameter collection_id is fully described in the schema with 'ID базы знаний из kb2_list', so schema coverage is 100%. The description does not add any parameter-specific semantics beyond what the schema already provides, 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 identifies the tool as returning a knowledge base document tree with parentId/children, distinguishing it from siblings like kb2_document or kb2_list. However, it lacks an explicit verb like 'get' or 'retrieve', making it slightly less direct than ideal.

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 this tool versus alternatives like kb2_list or kb2_search. The requirement for scope 'note' is a prerequisite but not usage direction. There is no mention of hierarchical use cases or comparisons with flat-list tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It adds valuable information about visibility (only bases shared with the webhook user) and permission requirements, as well as default type behavior. It does not explicitly state read-only nature, but 'list' implies that, and the provided traits are sufficient for this simple tool.

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

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

The description is concise, consisting of two sentences with the core purpose front-loaded. It efficiently conveys scope, visibility, and permission without 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 low-complexity tool with one optional parameter and no output schema, the description covers the key aspects: purpose, type filtering, default behavior, visibility, and permission. It does not mention pagination or output format, but those are not critical for a simple list and no output schema is provided.

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% for the single parameter, so baseline is 3. The description adds meaning by explaining the default behavior ('По умолчанию возвращает и standalone-базы... и привязанные к рабочим группам'), which clarifies what TYPE='all' does. This goes beyond the schema's enum descriptions.

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

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

The description clearly states the tool's purpose: 'Список баз знаний портала' (list of portal knowledge bases). It also specifies the scope (both standalone and workgroup bases). However, it does not differentiate from the sibling tool kb2_list, so it lacks explicit sibling distinction.

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

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

The description provides context about default behavior and a prerequisite (requires webhook 'landing' permission), which implies when to use it. However, there is no explicit guidance on when to use this tool versus alternatives like kb2_list, or clear 'do not use when' conditions.

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

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

With no annotations provided, the description carries the transparency burden. It discloses that the tool fetches blocks and concatenates them into full text, offers format options (markdown/text/html), and requires the 'landing' webhook permission. This is meaningful behavioral context, though it omits error handling and explicit return 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?

The description is two sentences, front-loaded with the core purpose, then the method, format choices, and permission requirement. Every sentence contributes useful information without redundancy or fluff.

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

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

For a relatively simple tool with no output schema, the description covers the essential aspects: what it does (full text), how it works (concatenates blocks), output formats, and required permissions. It falls short of fully specifying the return structure or edge-case behavior, but is largely complete for practical invocation.

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

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

The schema already describes all three parameters (landing_id, scope, format) with full coverage. The description repeats the default format and the 'from kb_sections' source, but adds no new semantic information beyond the schema. 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 clearly states the tool's function: retrieving the full text of a knowledge base page by its landing_id, collecting and concatenating page blocks. It distinguishes itself from sibling search/document tools by focusing on full-page content extraction.

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 (when you have a landing_id and need full page text) and mentions a required webhook right, but it does not explicitly contrast with alternative tools like kb2_document or describe when not to use it. Usage is understood but not strongly guided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It adds 'READ-ONLY' and 'limited block traversal', which are useful context about safety and search scope. However, it does not describe result format, pagination behavior, or what happens when limits are hit.

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 phrase that immediately signals READ-ONLY and the core search function. No wasted words, and it effectively communicates the essence of the tool.

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

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

Given there are 6 parameters and no output schema, the description is somewhat sparse. It hints at limited traversal but does not explain return values, sorting, or how to interpret results. The schema covers parameters well, so the description's brevity is partially mitigated.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself provides no additional parameter-level meaning beyond what the schema already documents, which is detailed and self-explanatory.

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 searches for text in titles and content of Landing knowledge base pages, with a specific mention of limited block traversal. This gives a specific verb+resource+scope, though it does not explicitly differentiate from similar sibling tools like kb2_search.

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 this tool over alternatives such as kb2_search or kb_list. The description lacks any context about prerequisites or exclusions, and the only recommendation (site_id for large portals) appears in the schema, not the description.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals that system pages are hidden by default, requires 'landing' webhook permission, and returns a flat list with parent pointers, which is valuable beyond the schema.

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

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

The description is four concise sentences, each with distinct value: purpose, return format, default behavior, and permission requirement. No filler.

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

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

Given no output schema or annotations, the description provides adequate context: purpose, input, permission, and defaults. However, it does not elaborate on the full response structure beyond is_folder and parent_id, leaving some ambiguity about what fields are returned.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description adds context about site_id origin and the include_system default, which aligns with the schema but does not add new meaning.

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

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

The description clearly states the tool returns pages and sections of a knowledge base by site_id, with a flat list structure including is_folder and parent_id, which distinguishes it from siblings like kb2_tree and kb_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?

It specifies the use case 'for building a tree' and references site_id from kb_list, giving clear context for when to use. However, it doesn't explicitly exclude alternatives or name sibling 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 discloses a key behavioral trait by labeling the tool as 'READ-ONLY', which is valuable since no annotations are provided. However, it does not mention the report structure, grouping logic, or any other behavioral details. This is only partial transparency for a tool with no annotation support.

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 sentence, front-loaded with the safety signal 'READ-ONLY' and directly stating the purpose. There is no filler or redundancy, making it extremely concise and well-structured.

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

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

Given the tool has 8 parameters and no output schema, the description is too sparse. It does not explain what the report contains, how projects are grouped, how 'completions' are determined, or any output structure. An agent would lack essential context to anticipate the tool's behavior.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal extra meaning by referencing the three report categories (active work, testing, completions), which loosely maps to parameters like in_progress_match and testing_match, but it does not deepen understanding beyond the schema.

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

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

The description clearly states the tool's purpose: to collect a unified report on active work, testing, and completions for multiple projects. It uses a specific verb ('collect') and specifies the resource ('unified report') and scope ('multiple projects'), distinguishing it from narrower sibling tools like tasks_in_progress or tasks_completed_period.

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 a usage context: when a multi-project aggregated report is needed. However, it does not explicitly compare with alternatives or state when not to use it. The 'for multiple projects' phrase provides some guidance, but it lacks explicit exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context about the ordering of stages and the cutoff at 'In process', but it does not disclose the tool's read-only nature, return format, handling of completed tasks, or stage-matching behavior. The schema covers some parameters (e.g., exclude_completed, in_progress_match), but the description itself remains limited.

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, focused sentence that immediately conveys the tool's core purpose and scope: 'Бриф проекта: стадии канбана по порядку до "В процессе" включительно, с задачами каждой стадии'. It is concise, front-loaded, and contains no superfluous information.

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

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

Given the tool has 7 parameters, no output schema, and no annotations, the description provides a clear overall concept: a brief of ordered kanban stages up to 'In process' with their tasks. This is sufficient for understanding the primary use case, though it does not mention parameter interactions, edge cases, or default exclusions. The schema fills in some gaps, but the description could be slightly more complete in explaining the tool's position relative to other project-related tools.

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

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

Schema description coverage is 100%, with each parameter having a meaningful description. The tool description itself does not explain parameters, but the schema already provides sufficient semantics. The description adds overall context about the output structure but does not enhance parameter understanding beyond what the schema already offers, 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 tool's function: it produces a project brief containing kanban stages in order up to 'In process' inclusive, along with tasks for each stage. This is a specific verb+resource+scope combination, distinguishing it from sibling tools like tasks_by_stage or project_stages by emphasizing the ordered stages and the inclusion of tasks within a brief.

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 the tool: when a concise project brief covering kanban stages up to 'In process' is needed. However, it does not explicitly state when not to use it or mention alternatives, such as tools for other stage ranges or different summary formats. The scope is implied by the wording, but no direct guidance 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does mention the ordering by SORT, which is a useful detail, but it does not disclose return format, potential side effects (though it is a read operation), or the role of the is_admin parameter. The description is minimal and lacks explicit safety or behavioral context.

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

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

The description is a single, concise sentence that is front-loaded with the core purpose. Every word contributes meaning, and there is no redundant information. It is an example of efficient under-specification, not deficiency.

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 (2 parameters, no output schema), but the lack of annotations and output schema places more burden on the description. The description explains the core functionality and ordering but does not detail return values or any edge cases. It is minimally complete but lacks depth expected for a tool with no annotation support.

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

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

Schema description coverage is 100%, and both parameters are already described in the schema. The description adds no extra meaning beyond what the schema provides, such as the purpose of is_admin or format of group_id. Baseline of 3 is appropriate because 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 tool's function: getting kanban stages for a project, ordered by SORT. It uses a specific verb (Get) and a specific resource (project kanban stages). It does not explicitly distinguish from sibling tools, but the nature of the resource is clear 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?

There is no guidance on when to use this tool versus alternatives. The description is purely functional and does not mention prerequisites, exclusions, or alternative tools. No context is provided for when this would be preferred over other task/stage-related 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?

No annotations are provided, so the description carries the full burden. It only states the action without disclosing side effects, permission requirements, behavior on conflicting parameters, or return values. Parameter descriptions disclose some behavior (e.g., local upload first goes to Drive) but the tool description itself is minimal.

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 front-loads the core purpose. No redundant information 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?

With 7 parameters and no output schema, the description is thin. It doesn't clarify valid parameter combinations (e.g., mutual exclusivity of file_id vs local_path) or expected behavior on success/failure. The full schema descriptions partially compensate, but completeness is only adequate.

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

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

Schema coverage is 100%, so all parameters have descriptions. The tool description adds a high-level summary of the two modes but does not go beyond what the schema already explains. 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 tool's purpose: attaching a file to an existing task, with explicit mention of two modes (file_id or local upload/base64). This distinguishes it from sibling tools like disk_upload or im_send_file.

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

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

Provides clear context (attach to existing task) and the two modes, but no explicit guidance on when to use this tool over alternatives or when not to use it. Sibling differentiation is implied rather than stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it merely states 'Create a new task' without mentioning side effects, permissions, irreversibility, or return behavior. This is a significant gap for a mutation tool.

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

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

The description is extremely concise (one short phrase), which is efficient, but it lacks substance and relies entirely on the schema. It is not verbose, but it under-specifies the tool's purpose and behavior.

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

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

The tool has 8 parameters and no output schema, so the description should explain what happens after creation (e.g., return value, follow-up actions). It provides none of that context, making it incomplete for an agent to use confidently.

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

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

Schema coverage is 100% with descriptions for all 8 parameters, so the schema already documents parameter semantics. The description adds no additional parameter context, matching the baseline of 3.

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

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

The description 'Создать новую задачу' clearly states the action (create) and resource (task). It is unambiguous and implicitly distinguishes from sibling tools like tasks_update, though it does not explicitly name them.

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

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

The description gives no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, context, or exclusions, leaving the agent to infer usage solely from the tool name and schema.

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

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

With no annotations provided, the description carries the transparency burden. It discloses that this is a WRITE operation and requires confirm=true, and points to a dry run for safety. However, it does not explain consequences (e.g., what happens to tasks, reversibility, side effects) or the effect of confirm=false beyond 'returns a hint.' 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?

The description is a single concise sentence that front-loads the core purpose and safety requirements. Every word earns its place, with no 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?

Given the 7-parameter schema which covers all inputs, the description provides the essential purpose and critical workflow (dry-run first). While it does not explain return values or delve into edge cases, the combination of schema and description is sufficient for an agent to select and invoke the tool correctly in most scenarios. It could be more complete by contrasting with tasks_complete, but the dry-run pointer mitigates that 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 parameters. The description only adds that confirm=true is mandatory, but that is already stated in the schema's confirm parameter. There is no additional semantic value beyond the schema, 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: 'переместить завершённые задачи в финальную стадию канбана' (move completed tasks to the final kanban stage), which is a specific verb+resource+scope. It also distinguishes from siblings by referencing the dry-run variant, making its role unambiguous.

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

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

It explicitly instructs to first use tasks_archive_dry_run, providing a clear workflow context. It also notes that confirm=true is required, which is an important invocation requirement. However, it does not explicitly contrast with related tools like tasks_complete or tasks_update, so it falls short of a full when/when-not matrix.

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

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

No annotations are provided, so the description carries the full burden. It explicitly discloses the key behavioral trait: 'Ничего не пишет' (writes nothing), and labels itself 'READ-ONLY'. However, it does not describe the return format (e.g., list of task IDs) or any other side effects, which is a minor gap given no output schema exists.

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

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

The description is concise and front-loaded with the most critical information ('READ-ONLY preview'). Every phrase adds value: it states the purpose, the object, and the safety guarantee. 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?

Given there is no output schema and the description is short, it still conveys the core purpose (preview which tasks would be moved). The word 'preview' implies it returns a list of tasks, but this is not explicitly stated. The tool is relatively simple, and the schema provides parameter details, so the description is mostly complete with a minor omission about the return value.

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 covers all 4 parameters with descriptions (100% coverage), so the baseline is 3. The description adds no extra meaning about the parameters themselves. It does not clarify how 'status' or 'final_stage_match' interact, but the schema already explains them adequately.

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 a specific verb ('preview') and resource ('завершённые задачи проекта' / completed tasks of the project), and explicitly marks it as 'READ-ONLY'. This distinguishes it from the sibling 'tasks_archive' which likely performs the actual move. The scope is unambiguous.

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

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

The description provides clear context: this is a dry-run preview to see which completed tasks would move to the final stage, without performing any writes. It implies its use as a pre-check before the actual archive operation, but does not explicitly name the alternative tool (tasks_archive) or state 'use when you want to preview before archiving'.

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

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

No annotations are provided, so the description bears full responsibility for disclosing behavioral traits. It only states the basic action and does not mention pagination, sorting defaults, read-only nature, potential side effects, or any operational constraints beyond what the schema already shows. The schema does include some behavioral hints (e.g., pagination step 50, default sort), but the description adds no extra 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 description is a single, concise sentence: 'Получить задачи конкретной канбан-стадии проекта (GROUP_ID + STAGE_ID)'. It is front-loaded with the core purpose and includes key parameter hints. There is zero wasted words or redundant content, making it highly efficient.

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 6 parameters, nested objects, and no output schema, yet the description offers only the barest purpose. It does not explain what the response looks like, how to interpret the returned data, or the relationship to related tools like project_stages. The schema covers parameter details but not the broader context needed for an agent to fully understand the tool's role and limitations.

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 a description for every parameter (100% coverage), including group_id and stage_id, along with a filter example and pagination hints. The description itself does not add any parameter semantics beyond what the schema already provides, so the baseline score of 3 is appropriate. There is no additional explanation of parameter relationships or formats that would elevate the 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: obtaining tasks of a specific kanban stage of a project, with the required parameters GROUP_ID and STAGE_ID. It specifies a verb ('get'), a resource ('tasks'), and a specific scoping (by stage), which distinguishes it from generic task list tools like tasks_list or tasks_my. However, it does not explicitly contrast itself with sibling tools, so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention typical use cases, exclusions, or relationships with sibling tools such as project_stages or tasks_list. The agent is left to infer usage solely from the name and parameter schema, which is insufficient.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says 'get messages' without explaining pagination, ordering, default limit behavior, or what constitutes a 'message' in a task chat. Mutating or safety aspects are not addressed.

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

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

The description is a single, short sentence that front-loads the core purpose. No wasted words or redundant 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 no output schema and no annotations, the description is too terse to be complete. It omits pagination semantics, response format, and differentiation from similar sibling tools, making it minimally viable but with 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% via the input schema, which already documents limit, task_id, and first_id. The description adds no additional meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description states a specific verb and resource: 'Get messages from task chat' (Получить сообщения из чата задачи). It is clear and unambiguous, but it does not explicitly differentiate from sibling tools like tasks_comments or im_chat_messages, which could also relate to task communications.

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 regarding when to use this tool versus alternatives. The description is a bare statement with no context about scenarios, prerequisites, or exclusions, leaving the agent to infer appropriate usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action 'add a comment' and does not mention side effects, permissions, reversibility, or any other behavioral traits.

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 starts with the action and contains no filler. It is appropriately sized for a simple 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?

The tool is simple and the schema covers all parameters, but the description lacks any usage context or behavioral notes. It is minimally complete for a straightforward add-comment operation, but would benefit from additional guidance.

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 describes both parameters (task_id and text) with 100% coverage. The description adds no additional meaning beyond what the schema already provides, 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 uses a specific verb 'add' and resource 'comment to a task', clearly indicating the tool's function. It distinguishes itself from siblings like tasks_search_comments and tasks_comments by emphasizing the creation of a new 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?

The usage is implied by the description and name: it is for adding comments to tasks. However, it does not explicitly mention when to use this tool over alternatives, nor does it provide any exclusions or context about related tools such as tasks_comments or tasks_update.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It only states 'get comments', implying a read operation but not detailing return format, error behavior, authentication, or pagination. This is insufficient for full 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 description is a single concise sentence that directly conveys the tool's purpose. It contains no unnecessary words or redundant information, and is front-loaded with the key verb and object.

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

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

The tool is simple with one parameter and clear purpose, but the lack of an output schema and usage guidelines leaves gaps. The description doesn't explain return value structure or when to use this over related tools, making it minimally complete despite low complexity.

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

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

The input schema fully documents task_id with a description, achieving 100% coverage. The tool description adds no additional parameter semantics, so the schema is the primary source of parameter information, making the baseline 3 appropriate.

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

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

The description 'Получить комментарии задачи' clearly states the action (get) and resource (task comments), distinguishing it from sibling tools like tasks_comment_add (add comment) and tasks_search_comments (search comments). It is specific and unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives such as tasks_search_comments or tasks_comment_add. There is no mention of prerequisites, use cases, or exclusions.

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

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

There are no annotations, so the description must disclose behavioral traits, but it does not. It only says 'complete task' with no mention of effects, reversibility, permissions, or return value, essentially restating the tool name.

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 brief, but this is under-specification rather than efficient conciseness. It contains no wasted words, but also provides barely more than 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 mutating tool with no annotations and no output schema, the description should clarify what 'completing' entails, any side effects, and how it differs from related sibling tools. It offers none of that context.

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

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

The schema already covers the single parameter (id) with a description ('ID задачи'), and the tool description adds no additional meaning. Baseline 3 applies due to 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 the action ('complete') and the resource ('task'), so it is clear what the tool does. However, it does not distinguish itself from sibling tools like tasks_update or tasks_archive.

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 no guidance on when to use this tool versus alternatives such as tasks_update or tasks_archive. No context, prerequisites, or exclusions are given.

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

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

With no annotations, the description adds valuable non-obvious behavior: tasks can be found via CLOSED_DATE or, for tasks in final kanban stages, via CHANGED_DATE. It also clarifies the primary filter semantics. It does not mention return format or side effects, but the core matching trap is 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 front-loaded sentence that states the main purpose, then adds the fallback nuance. Every word earns its place; there is no filler or unnecessary 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?

Despite having 9 parameters, nested objects, and no output schema, the description captures the core behavioral model and the key fallback logic. The schema covers parameter-level details such as pagination, ordering, and filter restrictions, so the description is sufficiently complete for a list/reporting tool.

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

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

The input schema already provides 100% coverage of all 9 parameters, including detailed descriptions of defaults, constraints, and the stage_closed_fallback mechanism. The description's mention of CLOSED_DATE/CHANGED_DATE largely restates schema content without adding new parameter-level meaning.

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

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

The description clearly identifies the tool as returning completed tasks for a period and specifies the primary date filter (CLOSED_DATE) plus a fallback by CHANGED_DATE for final kanban stages. This distinguishes it from sibling period tools like tasks_new_period and tasks_in_progress.

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

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

The description implies usage for completed-task reporting with a period filter, but it does not explicitly compare against alternatives or state when not to use it. No direct alternatives or exclusions are mentioned, so usage guidance is only implicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It adds two valuable behavior notes: the server does not truncate DESCRIPTION (returns as-is from Bitrix24), and include_attachments adds normalized attachments via UF_TASK_WEBDAV_FILES. However, it does not clarify whether the tool is read-only, what fields are returned by default when select is omitted, or any potential side effects. The notes are helpful but incomplete.

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

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

The description is concise: two sentences total. The first sentence front-loads the purpose, and the second adds a targeted recommendation. Every word earns its place, and there is no padding or repetition of schema 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 get-by-id tool, the description is adequate but not fully complete. It does not explain what 'detailed information' includes by default, what happens when select is omitted, or the structure of the return value. Since there is no output schema, the description could have described the default return shape or the effect of omitting select. However, the simplicity of the tool and the presence of parameter descriptions mitigate this 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 all three parameters already have descriptions in the input schema. The description adds extra value by recommending a specific select array for summary queries and clarifying that the server does not trim DESCRIPTION. This goes beyond the schema's basic field listing and helps the agent construct better requests.

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

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

The description clearly states the tool's function: 'Получить детальную информацию о задаче по ID' (get detailed information about a task by ID). The verb+resource is specific and distinct from sibling tools like tasks_list or tasks_search_text, which are not ID-based. The recommendation about using select with DESCRIPTION adds a useful pointer without obscuring the core purpose.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives. There is no mention of 'use this when you have a task ID' or any exclusions like 'do not use for summary queries without select'. The only hint is the select recommendation, which is about parameter usage, not tool selection. This leaves the agent to infer appropriate contexts.

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

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

With no annotations, the description carries full burden. It discloses that the stage is found automatically by name, which is key behavioral context. However, it does not mention whether the operation is read-only, error behavior, or default sorting, leaving gaps.

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 one short sentence, front-loaded with the main purpose, and every word adds value. It is a model of 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?

Given 6 params and no output schema, the description provides the core shortcut context but lacks information about return results, default behaviors, and usage boundaries. The schema covers parameter details, but the overall description is minimal for a tool with moderate complexity.

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

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

Schema coverage is 100%, so description is not required to repeat params. It does add context for in_progress_match by explaining the auto-detection mechanism, but other parameters (order, start, filter) are only handled by the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool returns tasks from the 'In progress' stage of a project, and adds that it's a shortcut with automatic stage lookup. However, it lacks an explicit verb (e.g., 'list' or 'get'), though the name implies the action.

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 'shortcut' phrasing implies when to use this tool (for 'In progress' tasks with automatic stage detection), but no explicit alternatives or exclusions are given. Users infer that a stage-based shortcut is preferable, but no sibling tools are named.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the basic read operation. It does not explain default behavior (e.g., how many items are returned, default sorting, whether 'select' is required) or any potential side effects, leaving the agent without important context beyond the schema.

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

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

The description is a single, concise sentence that directly states the tool's purpose. There is no wasted content, and the structure is appropriately 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?

Given the tool has 4 parameters, nested objects, no output schema, and no annotations, the description is too sparse. It does not clarify what is returned, how pagination works, or when this tool is preferable to the many sibling task-list tools, making it incomplete for effective selection and invocation.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description's mention of 'filtering and sorting' adds a small amount of semantic context, but does not elaborate on parameter usage beyond the schema. This matches the baseline for high 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 the tool returns a list of tasks with filtering and sorting. However, it does not distinguish from sibling tools like tasks_my or tasks_search_text beyond the generic 'list' noun, which may confuse an agent about the exact scope.

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

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

No guidance is provided about when to use this tool versus alternatives. The description does not mention exclusions, prerequisites, or use cases where another sibling tool would be more 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?

With no annotations, the description carries the full burden. It usefully discloses deduplication and the union of executor/assignor roles, but omits any mention of return format, pagination, status handling, or side effects. This is partial but not comprehensive disclosure.

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

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

A single, tightly-phrased sentence communicates the tool's purpose without any waste. It is front-loaded with the tool name and immediately explains the unique behavior.

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

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

The tool has 4 optional params and no output schema or annotations. The description explains the core behavior, but lacks return value details and usage context. It is a minimum-viable description for a list/read tool, not a full specification.

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 all four parameters documented in the input schema. The tool description adds no extra parameter meaning, so the baseline of 3 is appropriate.

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

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

The description states the tool combines tasks where the user is the executor and where the user is the assignor, with deduplication. This is a specific verb (объединить) + resource (задачи) and clearly distinguishes from generic task listing tools like tasks_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 use for retrieving the current user's combined tasks, but provides no explicit when-to-use guidance or alternatives. It does not mention when to prefer this over tasks_list or tasks_search_text.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the query intent and does not clarify read-only nature, pagination behavior, default filtering of closed tasks, or the return shape.

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 front-loads the core function and context. No redundant 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?

Given the tool's complexity (9 parameters, nested objects, no output schema, no annotations), the one-sentence description is insufficient. It does not describe the returned data structure, pagination semantics, or important filtering caveats.

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 provides descriptions for all 9 parameters (100% coverage), so the baseline is 3. The description adds no parameter-specific meaning beyond the period and CREATED_DATE concept, which is already present in the schema.

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

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

The description clearly states that the tool lists new tasks in a period based on CREATED_DATE, which is specific and identifies the resource and operation. It also mentions the intended report section ('new directions'), but it does not explicitly differentiate from sibling tools such as tasks_completed_period.

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

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

The description provides clear context for when to use the tool: for the 'new directions' section in a report. However, it does not mention when not to use it or name 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?

The description explicitly labels the tool as READ-ONLY, providing a clear safety signal in the absence of annotations. However, it does not disclose the return format (e.g., list of user IDs, names, counts) and leaves ambiguous how multi-project arrays are handled—whether counts are aggregated or per project. This is a partial disclosure beyond structured fields.

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

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

The description is a single, concise line in Russian that front-loads the READ-ONLY safety label and succinctly conveys the core functionality. Every word earns its place, with no filler or redundancy.

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

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

Given the absence of annotations and an output schema, the description carries the full burden but fails to describe what the tool returns (e.g., performer names, counts) or how it handles multiple projects. The core purpose is clear, but the missing behavioral context (aggregation, output shape) makes it incomplete for a tool with 4 parameters.

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 covers 100% of parameters with descriptions, so the baseline is 3. The description's mention of 'N' and 'В процессе' maps to threshold and stage_match, but adds no additional meaning beyond the schema's own parameter descriptions. No compensation needed.

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

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

The description clearly states the tool identifies performers with an overload of in-progress tasks exceeding a threshold (N) per project(s). The phrase 'исполнители с перегрузкой' explicitly names the resource (performers) and the condition, distinguishing it from siblings like tasks_in_progress or tasks_by_stage.

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

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

No guidance is given on when to use this tool versus alternatives such as tasks_in_progress or tasks_stale. The READ-ONLY prefix is a safety hint, but there is no explicit context for choosing this tool over others, nor any exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden. It adds the useful 'READ-ONLY' label and states the intentional limitation to an explicit task list, which is a behavioral constraint. However, it does not disclose other traits like case-insensitivity (though schema does), return format, or behavior with no matches. It provides some value beyond the schema but not extensive depth.

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 front-loads the critical 'READ-ONLY' label and immediately states the action and scope. Every word earns its place, with 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 read-only search tool with three well-documented parameters and no output schema, the description adequately conveys the core purpose and key constraint. It does not explain the return value or pagination, but the simplicity and schema richness reduce the need for more. A brief note on result ordering or defaults could push it to 5, but it's sufficiently complete.

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

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

Schema coverage is 100%, with parameter descriptions already explaining the search is case-insensitive, that task_ids are candidates from a narrow list with a 50-item limit, and that global traversal is intentionally not performed. The tool description adds no parameter-related information, so it meets the baseline without 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 clearly states the action (find text in comments) and the specific scope (explicitly passed limited list of tasks), distinguishing it from broader search tools like tasks_search_text. The verb and resource are specific, and the limitation to a provided task list differentiates it from global search.

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 implicitly indicates when to use this tool: when you have a specific, limited list of task IDs to search within comments. It also implies not to use it for global searches. However, it does not explicitly name alternative tools or state when not to use it, so it stops short of full guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explicitly states 'READ-ONLY', which is a key safety signal. It also discloses the local filtering and paginated traversal approach, implying that the tool may be slower and generate many REST requests—important operational context. It does not mention specific output or error behavior, but the basics are covered.

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 critical 'READ-ONLY' flag front-loaded. It avoids redundancy and every phrase earns its place by conveying purpose and method efficiently.

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 absence of an output schema and annotations, the description covers the essential aspects: purpose, read-only nature, and the search mechanism. The parameter schema is extremely detailed, covering pagination and filtering options. While it doesn't describe return values, for a search tool this is often self-evident, and the description is sufficient for an agent to use the tool correctly.

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

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

Schema coverage is 100%, so each parameter already has a description. The tool description adds overarching context about local filtering and pagination, which informs understanding of max_pages and max_results, but it does not add detail to individual parameters beyond what the schema already provides. Thus 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 states a specific action: find text in task titles and descriptions. It clearly distinguishes itself from sibling tools like tasks_search_comments, which searches comments. The method (local filtering with paginated traversal) is also mentioned, adding precision.

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

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

The description provides clear context: use when you need to search for text within task titles or descriptions. It does not explicitly list alternatives or when-not-to-use cases, but the context is sufficiently clear for an AI agent to select this tool appropriately among siblings.

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

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

With no annotations provided, the description carries the transparency burden. It explicitly discloses the read-only nature ('READ-ONLY') and adds a behavioral detail about the date basis ('по createdDate'). It does not describe return format, but for a simple read-only query tool 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 a single front-loaded sentence that states the key purpose and read-only nature without unnecessary detail. Every word earns its place, and it is easily scannable.

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 schema is fully documented and the tool is a straightforward filtered list, the description provides enough context to select and invoke the tool correctly. The minor ambiguity around 'на стадии дольше N дней' vs 'по createdDate' prevents a perfect score.

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 provides 100% coverage with descriptions for all five parameters, so the baseline is 3. The description adds only a loose mapping between N days and min_age_days, plus the createdDate hint, without significant new parameter meaning.

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

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

The description clearly states the tool lists long-lived tasks ('задачи-долгожители') that have been in a stage longer than N days, based on createdDate. It uses a specific verb and resource with scope, distinguishing it from siblings like tasks_by_stage or tasks_in_progress.

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

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

The description clearly implies use for finding stale tasks, and the READ-ONLY label helps set expectations. However, it does not explicitly mention when to prefer this over alternative task list tools, so it stops short of full guidance.

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

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

With no annotations, the description carries the full burden but only states 'update task by ID'. It does not disclose whether it performs partial or full updates, what happens on invalid fields, authorization requirements, or the return format. The schema hints at flexible fields but adds no behavioral context beyond the schema.

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

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

The description is a single, focused sentence with no redundant words. It front-loads the action and target, making it easy for an agent to grasp the core purpose quickly.

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

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

For a generic update tool with no annotations and no output schema, the description is too sparse. It does not explain field constraints, update semantics, return values, or how to handle partial updates, and it fails to differentiate itself from the numerous task-mutation siblings.

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

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

Schema description coverage is 100%: both id and fields have descriptions, and fields includes an example of the expected structure. The description adds no additional parameter semantics beyond what the schema already provides, so a 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 'Обновить задачу по ID' clearly states a specific verb (update) and resource (task by ID), distinguishing it from siblings like tasks_add (create) and tasks_complete (specific status change). It is concise and unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention exclusions or relationships with siblings such as tasks_complete, tasks_archive, or tasks_add, leaving the agent to infer usage from the name alone.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It only states a simple read operation, but does not specify what 'information' includes, response format, or error behavior, which is a significant gap for a get-by-ID tool.

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

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

The description is a single, concise sentence that immediately conveys the tool's purpose with 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 single-parameter lookup tool, the description with schema provides a clear picture. It lacks detail on return payload or edge cases, but given the tool's low complexity, it is reasonably complete.

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

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

Schema coverage is 100%: the 'id' parameter is already described as 'ID пользователя'. The description adds no further semantic nuance, 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 'Get information about a user by ID' uses a specific verb and resource, and explicitly states the lookup key (ID), distinguishing it from sibling 'user_search' which implies search-based lookup.

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

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

The description implies the tool is used when a user ID is known, but it offers no explicit guidance on when to prefer this over alternative tools like user_search, nor any exclusion criteria.

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

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

No annotations are provided, so the description carries the burden. It only states the search action but does not specify return format, matching behavior (partial vs exact), authentication needs, or whether it is read-only.

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 easy to parse, with 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?

The tool is simple (one parameter, no output schema). The description conveys the core purpose but lacks explicit information about the return value (list of users vs IDs) or pagination. However, for a basic search tool, it is largely adequate.

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

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

Schema coverage is 100% with the query parameter described as 'Имя или email' (name or email). The tool description repeats this same information without adding further detail about formats or search behavior.

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

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

The description clearly states the action (search), the resource (users), and the search criteria (name or email), distinguishing it from sibling user_get which retrieves a specific 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 the tool is used to find users by name/email, but it does not explicitly mention when to prefer it over alternatives like user_get, nor any exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'get' without clarifying whether the operation is read-only, what the response contains (chat object, ID, messages), or how errors are handled. This is a significant gap for a tool with no other metadata.

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 redundant words. It conveys the core purpose and lookup methods efficiently.

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 no output schema and no annotations, yet the description does not explain what the returned chat looks like or what additional context might be needed. For a tool with three optional parameters, the description is too thin to fully prepare an agent for correct invocation and interpretation of results.

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

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

Schema coverage is 100%, and the schema itself already provides rich descriptions for all parameters (e.g., group_id suppresses name search, group_name requires minLength). The description merely restates the lookup options without adding new meaning or usage nuances.

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 ('get the main chat') and target resource ('workgroup/project'), with two clear lookup methods (group_id or group_name). This distinguishes it from generic chat search tools like im_chat_find by focusing on workgroup chats.

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 the tool (when you need the main chat of a workgroup) but does not explicitly mention alternatives or when not to use it. Sibling tools like im_chat_find or im_chat_messages are not referenced, leaving some ambiguity about tool selection.

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