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

With no annotations, the description fully covers behavioral traits: offline processing, model download on first use, bounded worker pool, no writes to Bitrix, raw segments without speaker labels, audio quality caveats, and return structure. No contradictions.

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

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

Description is efficiently structured: purpose in first sentence, key details following. Every sentence adds value (e.g., model download, worker pool, no write, return format, audio quality). No waste.

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

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

Covers all necessary aspects for an agent: how it works, prerequisites, return format, limitations (no speaker labels, audio quality), and links to saving alternative. No output schema, but description compensates.

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?

Single parameter 'activityId' has 100% schema coverage with clear description. The tool description adds no additional parameter details beyond what the schema provides, meeting baseline but not exceeding.

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 transcribes CRM call recordings locally and offline, using specific verb 'Transcribe' and resource 'CRM call recording'. It distinguishes from siblings by emphasizing 'LOCALLY and fully offline' and mentions that it substitutes for Bitrix's UI-only transcription not available via REST API.

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 guidance on when to use (local transcription), notes first-call slowness due to model download, describes queue behavior for multiple calls, and explicitly states that the tool does NOT write to Bitrix (for saving, use alternative sibling tool). However, it does not compare with the sibling tools 'transcribe_fast' or 'transcribe_max'.

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?

Discloses key behaviors: runs locally, trade-offs (lowercase, no punctuation, no speaker labels), requires Python environment, returns clear error if missing deps, does not write to Bitrix, and brand auto-normalization. No annotations provided, so description carries full burden and excels.

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?

Well-structured with clear front-loading of the tool's purpose. While slightly long, every sentence adds useful information. Could be slightly more concise, but overall 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?

Covers input, output format, dependencies, error handling, and post-processing. No output schema exists, but description includes return fields. Complete for the tool's 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% for the single parameter `activityId`. Description adds context that it is a VOXIMPLANT_CALL activity, which aids understanding beyond the schema's description.

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

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

Clearly states the tool does FAST transcription using GigaAM v2 model, distinguishing it from the default and max tiers. The verb 'transcribe' combined with 'fast' and resource 'CRM call' is specific.

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

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

Explicitly says when to use: 'when you want the gist fast/cheap and don't need Whisper's punctuation or the max tier's dual-transcript + diarization.' Also explains the three-tier trade-off and that it does not write to Bitrix, directing to save with another tool.

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

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

Given no annotations, the description fully discloses the tool's internal behavior: it runs three models (GigaAM, Whisper, pyannote), returns raw materials for reconciliation, is slower than basic, and lists potential error types. It also mentions auto-normalization of brand names. This is complete 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 relatively long but well-structured with bullet points and clear sections. Each sentence adds value, though it could be slightly more concise without losing important details. The front-loading is effective with the core purpose stated first.

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

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

The description covers all necessary context: input (activityId), complex output format (whisper_text, gigaam_text, segments, etc.), post-processing instructions (reconciliation steps), system requirements, error handling, and even notes brand name normalization. It is fully self-contained for an AI 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?

With schema coverage at 100%, the description adds minimal new information about the required 'activityId' parameter beyond what the schema provides ('The call activity ID (a VOXIMPLANT_CALL activity)'). The description contextualizes it as part of the broader use case but does not enhance semantic understanding of the parameter itself.

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 it provides 'MAX-quality transcription of a CRM call' and explicitly distinguishes it from the sibling tool 'bitrix24_call_transcribe' by stating it's for when the basic version isn't good enough. The verb 'transcribe' and resource 'CRM call' are specific.

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

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

The description explicitly states when to use this tool ('when the basic bitrix24_call_transcribe isn't good enough'), outlines prerequisites (heavy Python env, HF token), explains error conditions and how to respond, and suggests a follow-up tool (bitrix24_crm_timeline_note_save). This provides comprehensive usage guidance.

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

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

No annotations provided, so description carries full burden. Discloses file resolution behavior, transcript gaps, note pipeline coverage, and signature image classification. Transparent about limitations.

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

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

Long but all content is valuable. Front-loaded with purpose. Slightly verbose but justified by complexity. Could benefit from clearer sectioning, but not detrimental.

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 params, nested objects, no output schema, description covers input semantics, behavior, edge cases (file resolution, transcript), and references sibling tools. Fully equips agent.

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%, baseline 3. Description adds significant value: explains filter semantics (e.g., PROVIDER_TYPE_ID), resolveFiles default and impact, order usage. 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?

Description clearly states tool lists timeline activities (calls, emails, SMS, meetings) on CRM entities (lead/deal/contact/company). Distinguishes from siblings for call duration, transcripts, etc.

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

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

Explicitly says when to use (e.g., see call log) and when not to (use voximplant for call duration, timeline note for transcripts). Provides clear alternatives and fallbacks.

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 provided, and the description does not disclose any behavioral traits such as error handling (e.g., missing ID), authentication requirements, or response structure. The minimal description fails to compensate for the lack of annotations.

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

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

Single sentence with no wasted words. Front-loaded purpose. Appropriate length for a simple retrieval 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?

No output schema and no description of what the response contains. For a 'get' tool, agents need to know the structure of the returned contact object. This omission leaves the tool incomplete.

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

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

The only parameter (contactId) is fully described in the schema with type and pattern. The description adds no additional meaning beyond the schema's own description. Schema coverage is 100%, so baseline 3 is appropriate.

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

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

Description explicitly states 'Get a single CRM contact by ID', clearly identifying the verb, resource, and filtering criterion. Distinguishes from sibling list tools like bitrix24_crm_contact_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?

Implies use when you have a contact ID, but no explicit guidance on when to use this versus alternatives like contact_list or other get tools. No exclusion criteria or prerequisites mentioned.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'List and filter', failing to mention default behavior, pagination, sort order, or side effects. The detailed filter operator notes are in the schema, not the description, so the description itself offers minimal 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 concise (4 words) and front-loaded with the action. It is efficient with no fluff, but it omits important context that could justify a slightly longer description. Still, it earns a 4 for being to the point.

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

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

For a list tool with no output schema, the description should disclose what is returned (e.g., array of contacts), default ordering, pagination limits, etc. It fails to provide this, leaving the agent with insufficient context to understand the tool's full 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 no additional meaning beyond 'List and filter'—it does not elaborate on parameters or their usage beyond what the schema already provides.

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

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

The description 'List and filter CRM contacts' clearly specifies the verb (list and filter) and resource (CRM contacts). It effectively distinguishes this tool from sibling tools like bitrix24_crm_contact_get (single contact) and bitrix24_crm_deal_list (deals).

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

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

The description implies usage when listing or filtering contacts but provides no explicit guidance on when to use this tool versus alternatives (e.g., get for single contacts) or any exclusions. No context about appropriate scenarios 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 full burden. It correctly indicates a read operation but does not disclose error handling (e.g., behavior for invalid ID), required permissions, or response structure. While it is functional, it lacks detail beyond the basic action.

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, well-constructed sentence with no superfluous words. It is front-loaded and easy to parse, earning full marks.

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 retrieval tool with one parameter and no output schema, the description is minimally adequate. However, it does not specify the return value (e.g., deal object fields) or potential errors, leaving some context gaps. A mention of the response would improve completeness.

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 parameters and describes 'dealId' as 'Deal ID'. The description adds no further semantic value—it merely echoes the schema. Since schema coverage is high, 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 verb 'get', the resource 'CRM deal', and the qualifier 'by ID'. This effectively distinguishes it from sibling tools like bitrix24_crm_deal_list, which deals with listing deals.

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 that this tool should be used when you have a specific deal ID and need a single record. It does not explicitly state when not to use it or mention alternatives, but the context of sibling tools (e.g., list, update) provides sufficient differentiation.

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 must disclose behavioral traits. The description text 'List and filter CRM deals' reveals nothing about truncation, pagination, or operator reliability, which are critical for correct invocation.

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

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

The description is extremely concise (5 words), but it provides only a basic purpose. It lacks structural elements like bullet points or contextual cues expected for a tool with 4 parameters.

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 (4 parameters, nested objects, no output schema), the one-line description is insufficient. Important details about return behavior and filtering are omitted from the description itself.

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 baseline is 3. The description adds no parameter meaning beyond the schema, but the schema's parameter descriptions are detailed. The description itself does not enhance semantics.

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 'List and filter CRM deals' clearly states the verb (list and filter) and the resource (CRM deals), differentiating it from sibling tools like bitrix24_crm_deal_get which retrieves a single deal.

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 (e.g., bitrix24_crm_deal_get for single deals). Usage context is implied but not stated.

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

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

No annotations are provided, so the description must convey behavior. It omits critical details such as read-only nature, idempotency, error handling (e.g., missing ID), or authentication requirements.

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

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

The description is a single, front-loaded sentence that conveys the core purpose without waste, though it could benefit from minimal additional context without losing conciseness.

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

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

For a simple retrieval tool with 100% schema coverage and no output schema, the description is minimally viable but lacks behavioral/usage context that would improve agent decision-making.

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 description adds no new meaning beyond the schema's 'leadId' description and pattern. The baseline of 3 is appropriate as the schema already documents the parameter 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 explicitly states the action (Get), resource (a single CRM lead), and method (by ID), clearly distinguishing it from sibling tools like bitrix24_crm_lead_list which lists leads.

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

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

The description implies usage when a specific lead ID is known but does not explicitly contrast with alternatives like bitrix24_crm_lead_list or provide 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?

With no annotations, the description bears full responsibility for behavioral disclosure. The one-line description only states the basic function and does not mention important traits like pagination, filtering behavior, or data safety. The parameter descriptions in the schema provide some behavioral notes, but those are not part of the tool's description field.

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

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

The description is extremely concise at five words, conveying the essential purpose without redundancy. However, it could benefit from a slightly more structured format, e.g., mentioning key features like filtering.

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 four parameters, no output schema, and no annotations, the description is insufficiently complete. It omits details about pagination limits, default behavior, typical use cases, and what the response looks like. The parameter descriptions help but are not part of the description field.

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% (all parameters have descriptions), so baseline is 3. The tool description adds no additional meaning about parameters beyond what the schema already provides.

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

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

The description clearly states the tool lists and filters CRM leads, specifying the resource (leads) and action. However, it does not explicitly differentiate from sibling tools like bitrix24_crm_deal_list or bitrix24_crm_lead_get, though the resource name provides implicit 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?

No guidance is provided on when to use this tool versus alternatives such as bitrix24_crm_lead_get for individual leads or list tools for other CRM entities. The description lacks any context for selection.

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 given, description carries full burden. It implies a read operation and lists return fields, but omits details like pagination, rate limits, or authentication requirements.

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

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

Two sentences, front-loaded with purpose, no fluff.

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

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

No output schema but description gives return fields. Adequate for a list tool, though missing details on default limit behavior or ordering.

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 4 parameters with descriptions (100% coverage). Description adds no extra meaning to parameters, so baseline 3 applies.

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

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

Description clearly states it lists manual timeline comments (manager notes) on CRM entities, distinguishes from activities and structured fields, and specifies return fields (COMMENT, AUTHOR_ID, CREATED).

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?

Mentioned usefulness for reviewing manager notes beyond structured fields, but lacks explicit when-not-to-use or comparison with sibling tools like activity list or note get.

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

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

With no annotations, the description carries full burden. It accurately describes a read-only operation that returns text or null, with no side effects. Could mention auth or error handling, but overall transparent.

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

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

Three sentences: purpose, return value, and usage guidance. No unnecessary text. Front-loaded and 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?

Given the tool's simplicity, the description covers input (referencing schema), output (note text or null), and context (use before saving). No gaps for a read tool with 100% schema coverage.

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

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

Schema coverage is 100%, so baseline is 3. The description adds little beyond what the schema already provides, e.g., clarifying that 'itemId' for a call note is the call activity's ID. No significant added 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 it reads a note attached to a CRM timeline item, specifies the return value (note text or null), and distinguishes from the sibling tool 'bitrix24_crm_timeline_note_save' by implying this is the getter.

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

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

Explicitly tells the agent to use this before saving to avoid overwriting existing notes or transcripts. This provides clear context for when to use the tool versus 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?

No annotations are provided, so the description fully covers behavioral traits: note replacement, mode-specific behaviors (draft file, return of existing note in create mode), and the exact effects of each mode.

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

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

The description is a single paragraph, efficiently covering purpose and all modes without redundancy. It could use slight structuring but is effective.

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 complexity (three modes, 6 parameters), the description explains all relevant details: the one-note constraint, mode behaviors, and parameter context. No output schema needed; return values are hinted.

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 has 100% description coverage, but the tool description adds significant context beyond schema (e.g., 'for a call note this is the call activity's ID' for itemId, and mode behavior details). It adds 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 states the verb 'save' and the resource 'note on a CRM timeline item', with a specific example of call notes. It distinguishes from generic note saving by specifying the timeline context.

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 guidance on the three modes (create, replace, append) and their effects, including the anti-clobber safeguard. It lacks direct comparison to sibling note retrieval tool but is otherwise clear.

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

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

No annotations are provided, so the description must fully disclose behavior. It reveals that results are sorted by last activity and limited to the current user's chats. However, it does not mention side effects (none expected), authentication requirements, or limitations like pagination or whether archived chats are included. This leaves moderate gaps for a safe 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 extremely concise, consisting of two short sentences that front-load the action and purpose. Every word contributes to understanding, with no unnecessary fluff or repetition. This is an excellent example of efficient documentation.

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 low complexity (2 optional parameters, no output schema), the description covers the core functionality well. It explains what the tool does, how the results are sorted, and the intended use case. However, it omits the default value for the limit parameter (50) and does not mention pagination behavior, which would be helpful for agents consuming large datasets.

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 full descriptions for both parameters (type and limit), with 100% coverage. The tool description does not add any additional meaning or context about these parameters beyond what is in the schema, resulting in no extra value. 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 lists IM chats the current user participates in, with a specific verb ('List') and resource ('IM chats'). It also indicates the output is sorted by last activity and provides a concrete purpose (discover chat IDs for reading messages), distinguishing it from sibling tools like bitrix24_im_chat_search and bitrix24_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 gives explicit usage context ('discover chat IDs for reading messages'), which implies when to use this tool. However, it does not explicitly mention when not to use it or name alternatives like bitrix24_im_chat_search for searching. The context is clear but lacks exclusions.

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

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

No annotations exist, so the description bears full burden. It expertly discloses the lossy nature of 'text' field, warns against using it for editing, and includes a real-world incident to underscore the risk. It also explains attachment handling, including default inlining of images and listing of non-image files. This is exceptional behavioral 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 well-structured: clear purpose, usage guidance, and then critical behavioral warnings. It is slightly lengthy but every sentence adds unique value, such as the pagination hint for 'firstId' and the editing caution. Minor redundancy could be tightened but overall 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?

Given the absence of an output schema, the description fully covers return fields (text, textRaw, files) and attachment behavior. It explains pagination, image inlining, and provides cross-reference to bitrix24_im_file_get. All essential context for an agent to use the tool correctly is present.

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 baseline is 3. The description adds value beyond the schema by clarifying DIALOG_ID formats for task chats ('chatNNN') and explaining the behavior of 'includeImages' and 'maxImages' defaults. This enriches understanding without redundancy.

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 'Read messages from a Bitrix24 IM chat' with a specific verb and resource. It further specifies use cases (task chats, group chats, 1-on-1 dialogs) and distinguishes from sibling tools like bitrix24_im_message_send, bitrix24_im_message_update, etc., by its reading function.

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 guides when to use the tool ('Use for reading task chats, group chats, or 1-on-1 dialogs') and provides critical formatting for DIALOG_ID. It also directs to bitrix24_im_file_get for non-image files. However, it does not explicitly state when not to use (e.g., for writing messages) or list sibling alternatives for other actions.

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

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

No annotations are provided, so the description bears the full burden. It correctly indicates a non-destructive search operation but does not disclose any additional behavioral traits such as authentication requirements, rate limits, or behavior on no results. The description is adequate but minimally informative 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?

Two sentences, no extraneous information. Every word serves a purpose, front-loading the core functionality and use case. Ideal conciseness.

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

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

For a simple search tool with one parameter and no output schema, the description covers the essential aspects: what it does (search), how to use it (by name/title), and when (finding specific chats). Minor missing details (e.g., case sensitivity, exact match) prevent a perfect score, but it is largely complete.

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

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

The input schema has 100% description coverage for the single 'query' parameter. The description adds no new meaning beyond the schema's description ('Search query (chat name or partial match)'), so it meets the baseline but does not enhance parameter understanding.

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

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

The description clearly states the verb 'Search' and the resource 'IM chats', specifying that it searches by name/title. It distinguishes itself from sibling tools like bitrix24_im_chat_list by focusing on search functionality, 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 provides clear context for when to use the tool, mentioning 'workgroup chats, project chats, or specific conversations'. However, it does not explicitly state when not to use it or directly contrast with alternatives like bitrix24_im_chat_list, though the context is sufficient for most agents.

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, description carries full burden. It reveals that images return viewable content while other files return metadata plus a webhook-authenticated download URL. Could add that it's read-only and safe, but current detail is good.

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

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

Two well-structured sentences. First sentence states purpose and identifier. Second sentence gives usage context and return behavior. No wasted words, 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?

Covers purpose, parameter, usage scenario, and return types for both image and non-image files. Lacks mention of errors or authentication details beyond 'webhook-authenticated', but overall sufficient for a simple fetch tool.

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

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

Schema coverage is 100% and both schema and description describe fileId similarly (numeric disk file ID from chat message files[]). Description adds no extra semantics beyond clarifying the source, which is already 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?

Specifically states 'Fetch a single file attached to a Bitrix24 chat message', giving clear verb and resource. Identifies the fileId from a related tool, distinguishing it from siblings like bitrix24_im_post_file and bitrix24_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?

Explicitly says 'Use this for attachments bitrix24_im_chat_messages didn't inline (non-images, or images past the inline size/count cap)', providing clear when-to-use guidance. Also describes what to expect for images vs other file types.

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 provided, so description carries full burden. It mentions authorization, but does not state whether deletion is irreversible or any side effects on replies/attachments. Some behavioral traits are implied but not fully 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?

Three sentences, all essential. No redundant information. The most important information (what the tool does) is front-loaded.

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

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

For a simple delete operation with one parameter, the description covers the key points. It lacks details on error handling or response format, but given no output schema, it is mostly 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?

The single parameter messageId is described in the schema, and the description adds value by specifying the source of valid IDs (from bitrix24_im_chat_messages or bitrix24_task_comment_list). This enhances parameter 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 action (delete), the resource (message), and scope (including task chats). It also directs to sibling tools for obtaining the message ID, distinguishing it from other message tools like update or send.

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 context on when to use (deleting a message) and prerequisites (message ID from specific tools). Also notes authorization restrictions (only author or admins). Could be more explicit about when not to use, but the context is sufficient.

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 fully discloses behavioral traits: the message is sent under the webhook owner's identity, returns the new message ID, the formatting limitations (BBCode only, no Markdown, specific tags), the file caption rule, and the mandatory disclosure line. This is comprehensive 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 relatively long but well-structured, starting with purpose and sibling relationships, then parameter details, formatting rules, and special cases. Every sentence earns its place, though it could be slightly more concise by grouping related information more tightly.

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 annotations, no output schema, and a complex tool with formatting and behavior nuances, the description is complete: it covers invocation, formatting, disclosure, file attachment behavior, and alternatives. There is little ambiguity left for the agent.

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 baseline is 3, but the description adds significant value: it explains dialogId format with concrete examples (e.g., '8' for Aleksandr, 'chatNNN'), details the text formatting contract (BBCode support, bullet list syntax, disclosure line), and adds the file-caption rule not found 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 the verb ('Send a NEW Bitrix24 IM message') and specifies the resource (private 1-on-1 or group/task chat). It explicitly distinguishes from sibling tools by naming bitrix24_im_message_update, bitrix24_im_message_delete, and bitrix24_task_comment_add, 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 provides explicit when-to-use scenarios (private message vs. group chat) and when-not-to-use (task comments should use bitrix24_task_comment_add). It also includes detailed formatting rules and a disclosure requirement, giving clear guidance on correct invocation.

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

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

With no annotations, description fully discloses key behaviors: wholesale replacement (no merge), author-only editing, and the risk of BBCode stripping if using wrong field. This is comprehensive 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?

Every sentence adds critical information. Well-structured: starts with purpose, then conditions, then warnings. Appropriate length for the complexity.

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

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

Given no annotations and no output schema, the description covers all essential aspects: operation, constraints, formatting, common pitfalls, and usage context. Nothing significant missing.

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

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

Despite 100% schema coverage, description adds significant value for the 'text' parameter: formatting details, disclosure line requirement, and warning about using 'textRaw' over 'text'. This goes beyond schema.

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

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

Description clearly states 'Edit the text of a Bitrix24 IM chat message' with specific verb and resource. Distinguishes from sibling tools like send and delete by focusing on editing existing 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?

Provides explicit constraints: only message author can edit, formatting rules (BBCode, bullet points, disclosure line), and warns against using stripped 'text' field. Gives clear instructions on constructing new text from 'textRaw'.

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 provided, so description carries full burden. Discloses internal implementation (im.disk.folder.get → disk.folder.uploadfile → im.disk.file.commit), behavior differences for images (inline preview) vs other types (downloadable), one message per file rule, oversized font caption caveat, and a historical curl bug. Very transparent.

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

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

Description is thorough but not overly verbose. Front-loaded with core purpose, then details. Every sentence provides useful information. Could be slightly tighter, but overall efficient for its comprehensiveness.

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 no output schema, description explains return type (array of message IDs). Covers file types, caption behavior, differences from siblings, internal flow, and usage notes. Very complete for an agent to understand 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?

Schema coverage is 100%, so baseline is 3. The description adds value beyond schema by explaining the caption rule (oversized font), reusing the same caption, and why to keep it short. It also reinforces handling of filenames with special characters. However, the schema already includes similar descriptions for each parameter.

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

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

The description clearly states the tool posts local files of any type into Bitrix24 chats, with explicit verb 'Post' and resource 'local file(s) into a Bitrix24 chat'. It distinguishes from siblings like bitrix24_im_message_send (text-only) and bitrix24_task_attach_file/bitrix24_task_post_image (task-only), making 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?

Provides explicit when-to-use (for any file reaching a chat), when-not-to-use (for long explanations, use separate message), and alternatives (hand-rolling with curl is discouraged). Also advises calling once per file for distinct captions and keeping caption to one short line.

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, description fully carries burden. Details two-step internal process (uploadfile then update), chat appearance without thumbnail, safety (preserves existing attachments), and the 'n<diskFileId>' encoding. No contradictions.

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

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

Single paragraph, well-structured with purpose first, then guidance, then behavior, then safety, then implementation detail. Slightly long but all sentences add value; no redundancy.

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

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

For a tool with 4 params and no output schema, description covers purpose, usage, behavior, parameter nuances, safety, and internal steps. No gaps for effective invokation.

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%. Description adds value beyond schema: explains default folder ID (732896) and its context (shared 'Блог' folder, writable for user 854), and that fileName defaults to basename. Provides override rationale for folderId.

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?

Clearly states the tool attaches a local file to a Bitrix24 task. Specifies file types and use cases (briefs, reports, signed-off specs). Explicitly distinguishes from sibling `bitrix24_task_post_image` for inline previews.

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 explicit guidance on when to use (delivering briefs, reports) and when not (images needing inline preview, alternatives given). Explains file appearance in chat (no preview) and safety behavior (append, not replace).

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 provided; the only behavioral hint is mutation (adds), but nothing about idempotency, side effects, or authentication requirements.

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

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

Single sentence of 8 words, front-loaded with the core action, no redundancy.

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

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

No output schema, no mention of return value (e.g., created item ID), no explanation of how this relates to checklists (e.g., if multiple checklists exist per task). Minimal context for a write operation.

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

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

Schema covers 100% of parameters with descriptions; the tool description adds no extra meaning beyond what the schema already provides.

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

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

Description clearly states the action (Add) and resource (checklist item) within a specific context (Bitrix24 task). It distinguishes from sibling tools like list or complete checklist items.

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

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

No guidance on when to use this tool vs alternatives, no prerequisites mentioned (e.g., task existence, permissions), and no conditions for effective use.

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

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

With no annotations, the description carries full burden. It only states the action ('complete') but does not disclose any behavioral traits such as idempotency, error handling, permission requirements, or whether the action can be undone.

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 with no unnecessary words. It is front-loaded and easy to parse.

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

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

The description covers the basic purpose but lacks any additional context about return values (no output schema) or behavior. For a simple mutation tool with 2 parameters, it meets minimum viability but leaves gaps in usage and behavioral understanding.

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 parameters described with patterns). The tool description adds no extra meaning beyond what the schema already provides, so 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?

Description uses a specific verb ('mark') and resource ('checklist item as complete'), clearly distinguishing it from sibling tools like checklist_list or checklist_add. The purpose is immediately understandable.

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 vs alternatives (e.g., when to mark complete vs update or delete). The description simply states the action without context.

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

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

The description does not disclose any behavioral traits beyond the basic read operation. It omits information about pagination, sorting, filtering, or potential side effects. Since no annotations are provided, the description carries the full burden but fails to add meaningful 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, clear sentence with no redundant information. Every word contributes to understanding the tool's purpose.

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

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

For a simple listing tool with one parameter and no output schema, the description adequately conveys the function. It could mention that the result is a list of items, but the purpose is clear 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?

Schema coverage is 100% for the single parameter 'taskId'. The schema already provides a description ('Task ID') and pattern constraint. The tool description adds no additional meaning, so it meets 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 action ('List') and resource ('checklist items') for a specific context ('for a Bitrix24 task'). It effectively distinguishes this tool from siblings like bitrix24_task_checklist_add and bitrix24_task_checklist_complete.

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

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

No guidance is provided on when to use this tool versus alternatives or when not to use it. The description lacks any context about prerequisites, scope, or relationship to 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?

Discloses behavioral traits beyond annotations (none provided): uses legacy forum API, posts to both chat and comment section, returns numeric ID to keep, requires a specific ending line ('(написано агентом)'), and explains BBCode limitations like Markdown not supported.

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 long but every sentence adds necessary context; it is well-structured with purpose, behavior, return value, usage tips, formatting rules, and a required disclosure. Could be slightly tighter but still 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?

Given the tool's complexity (two parameters, no output schema), the description fully explains the required usage pattern, return value, formatting nuances, and behavioral implications. No gaps remain.

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 100% of parameters, baseline 3. Description adds significant value by detailing BBCode patterns, the required disclosure line, and the text parameter's formatting constraints beyond the schema's short description.

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

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

The description states verbatim 'Add a comment to a Bitrix24 task' and distinguishes from siblings by explaining the return ID's usage for update/delete tools and explicitly separating file attachment via bitrix24_task_attach_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 explicit guidance: do not inline files, follow typical pattern (attach then comment), BBCode not Markdown, required disclosure line, and notes that [*]/[LIST] only work in descriptions. Clearly separates when to use this vs 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?

With no annotations provided, the description fully discloses behavioral traits: the deletion is permanent but replaced by a placeholder, authorization requirements, and the internal API call (im.message.delete). No contradictions exist.

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 sentences, directly front-loaded with the action, and every sentence adds value (purpose, source of ID, placeholder effect, authorization, internal call reason). No unnecessary words.

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

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

For a simple delete tool with one parameter and no output schema, the description covers all necessary aspects: what happens to the comment (placeholder), who can delete, and why a specific API is used. It is fully complete for the tool's 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 parameter with a description, but the description adds useful context: the commentId is the same as the IM message ID and originates from bitrix24_task_comment_add. This reinforces understanding beyond the schema, warranting a score above 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 clearly states the verb and resource: 'Delete a Bitrix24 task comment by ID.' It specifies the source of the ID (from bitrix24_task_comment_add) and distinguishes it from sibling tools by explaining the internal mechanism (im.message.delete) and the placeholder behavior, making the purpose unmistakable.

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

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

The description provides context on when to use the tool (to delete task comments) and specifies authorization (only author or admins). It implicitly guides the agent away from using generic IM deletion tools by noting the internal API call and webhook scope limitation, though it does not explicitly list 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 full burden. It discloses the fallback behavior and implies read-only operation. However, it does not mention pagination, sorting, or any potential side effects, which would further enhance 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 three sentences, front-loaded with the verb and resource, and every sentence provides value. No extraneous 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 no output schema, the description does not explain return format (e.g., fields like id, text, author). For a list tool, this is a gap. However, the tool name and sibling tools may imply structure, so not critically incomplete.

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 both parameters with descriptions, achieving 100% coverage. The description adds no additional semantic meaning beyond what the schema provides (e.g., no explanation of how limit interacts with fallback). 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 explicitly states 'Read task chat messages' and distinguishes from sibling write tools (add/update/delete) by specifying it is a read operation for task comments, with clarification that it reads from IM chat with fallback to legacy forum comments.

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 explains that modern Bitrix24 uses IM chat for task discussions and that this tool handles both modern and legacy formats via fallback. It gives clear context but does not explicitly mention when not to use it (e.g., versus other read tools like bitrix24_im_chat_messages).

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?

Discloses that `task.commentitem.update` direct REST returns ACTION_NOT_ALLOWED for typical webhook scopes, so the tool internally calls `im.message.update`. Also notes that comment ID equals IM message ID and only author can edit. No annotations provided, so description carries full burden and delivers well.

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 paragraph of 4 sentences, each serving a purpose: what it does, how to get comment ID, when to use, author constraint, and technical note. No redundant or irrelevant 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?

With no output schema and missing annotations, the description adequately covers purpose, parameters, usage guidelines, and behavioral nuance. It lacks explicit return value information, but given the tool's simplicity (update operation), it is sufficiently complete for an agent to 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?

Both parameters have schema descriptions. The description adds meaning beyond schema: for `commentId` it specifies 'returned by bitrix24_task_comment_add (same as IM message ID)', and for `text` it mentions 'BBCode — same conventions as add'. Schema coverage is 100%, baseline 3, but added context earns a 4.

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

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

Description clearly states 'Edit the text of an existing Bitrix24 task comment', specifying verb and resource. It distinguishes from sibling tool `bitrix24_task_comment_add` by noting that comment ID equals IM message ID and that this tool is for corrections. The purpose is unambiguous and differentiated.

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

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

Explicitly says 'Use this instead of posting a follow-up «UPD:» comment when you need to correct an earlier message' and states 'Only the comment's author can edit'. Provides clear context for appropriate use, though does not explicitly mention when to use alternatives like adding a new comment.

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 of behavioral disclosure. It only states 'mark as completed' without detailing side effects, permissions required, or whether the action is reversible.

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 with no unnecessary words. It is efficient but could include more detail without becoming verbose.

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

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

Given the lack of output schema and the minimal description, an agent lacks context on what happens after completion (e.g., status changes, notifications, or related actions). More detail is needed for a complete understanding.

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

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

The single parameter 'taskId' is fully described in the schema with type and pattern. The description adds no additional meaning beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states the action 'Mark a Bitrix24 task as completed', specifying the verb and resource. It distinguishes from sibling tools like 'bitrix24_task_start' and 'bitrix24_task_defer'.

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, nor any prerequisites or context for when it should or should not be used.

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 'create' but does not disclose side effects (e.g., notifications sent, permissions required, or whether task creation may fail silently). This leaves significant unknowns for the agent.

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

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

The description is a single sentence with no redundancy. Every word is necessary. It is efficiently 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 11 parameters, no output schema, and no annotations, the description is too minimal. It does not explain what the tool returns (e.g., result ID), error scenarios, or how to handle responses. Given the complexity, more context is needed.

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

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

Schema coverage is 100% with descriptions for all 11 parameters. The description adds no extra parameter meaning beyond the schema. 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 'Create a new Bitrix24 task' clearly states the verb and resource. It is specific and easily distinguishes from sibling tools like bitrix24_task_list (list), bitrix24_task_update (update), and bitrix24_task_complete (complete).

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

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

The description provides no guidance on when to use this tool vs alternatives. It does not mention prerequisites (e.g., user must exist), context, or when not to use it. Sibling tools exist for different operations, but no differentiation is offered.

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 but only states the action name. It does not disclose any behavioral traits such as changes to task state, reversibility, or side effects, making it insufficient for safe invocation.

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

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

The description is very concise, one short sentence, and front-loaded. However, it may be too brief, sacrificing detail for brevity. Still, it is efficient and to the point.

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 lack of annotations and output schema, the description should provide more context about what deferring means, expected outcomes, or usage constraints. It is incomplete for an agent to understand the tool's full 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 coverage is 100% and the parameter 'taskId' is described as 'Task ID' in the schema. The description adds no extra meaning beyond the schema, so it meets the baseline but provides no additional help.

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 clear verb 'Defer' and resource 'Bitrix24 task', indicating a specific action on a task. However, it does not differentiate this action from siblings like 'bitrix24_task_complete' or 'bitrix24_task_start', leaving ambiguity about what deferring entails.

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 does not mention context, prerequisites, or when not to use it, leaving the agent without decision support.

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 provided, so description carries full burden. Only states 'with full details', implying read-only retrieval but lacks specifics on permissions, error handling, or side effects. Insufficient for a read 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?

Single, efficient sentence that front-loads the core purpose. No extraneous 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?

Simple tool with one parameter and no output schema; description covers basic retrieval intent but does not elaborate on return structure or edge cases. Adequate for minimal completeness.

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% (taskId described as 'Task ID' in schema), so description adds no new meaning. Baseline 3 is appropriate.

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

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

Clearly states 'Get a single Bitrix24 task by ID with full details', with specific verb, resource, and scope. Distinguishes from sibling tools like bitrix24_task_list (multiple tasks) and update/mutate tools.

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

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

Implies use when you have a specific task ID and need full details, but provides no explicit when-not or comparison to alternative tools like bitrix24_task_list. Minimal guidance.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. The description omits important details such as pagination behavior, rate limits, or side effects. The schema includes a note about truncation at 1000 without limit, but that is not reflected in the description.

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

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

The description is a single sentence, which is concise and includes key information. However, it could be slightly more informative by including brief behavioral notes without adding much length.

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 lack of output schema, the description does not explain the return value structure. It also does not mention the truncation behavior or pagination. With 4 parameters and nested objects, more context would be helpful, but it is minimally sufficient.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds examples of filter criteria (status, responsible user), but these are already present in the schema descriptions. No additional meaning beyond the schema is provided.

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 verb ('list and filter') and resource ('Bitrix24 tasks'), with examples of filter criteria. This effectively distinguishes it from sibling tools like bitrix24_task_get (single task) or bitrix24_task_create.

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 listing and filtering tasks, but does not explicitly state when to use this tool versus alternatives. For example, it does not clarify that for a single task details, one should use bitrix24_task_get. General guidance is adequate but not 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?

Discloses that images render inline, each image gets a separate message due to a verified bug, files saved to disk folder 732896, permanently accessible but not added to task file field. Returns array of message IDs.

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?

Description is long but every sentence serves a purpose. Front-loads key features and differentiators. Could be slightly more concise but still 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?

Given complexity (4 params, no output schema, platform bug), description covers all needed context: return format, caveats, sibling tool relationship, and default 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?

Adds rich context beyond schema: explains separate message behavior per file, default folder verification, BBCode support, and per-image caption strategy. All parameters are well described.

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 posts chat messages with inline image thumbnails, distinguishes from bitrix24_task_attach_file, and notes that files are not attached to task file field.

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

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

Explicitly recommends use for screenshots, design mockups, photo evidence. Tells when not to use (for attaching to UF_TASK_WEBDAV_FILES) and points to sibling bitrix24_task_attach_file. Advises on per-image captions.

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

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

No annotations are present, so the description carries the full burden. It only states the action without disclosing side effects, return value, or authorization requirements. For a mutation tool, this is insufficient.

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 information. It earns its place.

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

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

For a simple two-parameter tool, the description is minimally adequate but lacks behavioral context (e.g., what happens if the move is invalid). In the presence of many sibling tools, more guidance would improve completeness.

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 both parameters have descriptions in the schema. The tool description adds no extra meaning beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states the action ('Move'), the resource ('a task'), and the context ('to a different Kanban stage'). It effectively distinguishes the tool from siblings like bitrix24_task_list or bitrix24_task_stages_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?

No guidance is provided on when to use this tool versus alternatives like bitrix24_task_update, or any prerequisites such as required permissions or stage existence.

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 disclosure. It implies a read-only operation by saying 'list', but does not explicitly confirm non-destructive behavior or mention authentication requirements. The description is adequate but 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, front-loaded sentence with no unnecessary words. Every part serves a purpose.

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

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

For a simple list tool with one parameter and no output schema, the description is fairly complete. It could mention the order or format of returned stages, but the current description suffices for basic usage.

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 description essentially repeats the parameter meaning from the schema ('entityId=0 for personal Kanban'). It does not add significant new information beyond what the schema already provides.

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

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

The description clearly states the tool lists Kanban stages and specifies the context (workgroup/project or personal with entityId=0). This distinguishes it from siblings like bitrix24_task_stage_move and bitrix24_task_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 provides clear context for when to use the tool, including the special case of entityId=0 for personal Kanban. However, it does not explicitly state when not to use it or mention 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?

No annotations are provided, so the description must carry the burden. It only states the status change but does not describe side effects (e.g., whether it sends notifications, updates timestamps, or is reversible) or authorization requirements.

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

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

The description is a single, concise sentence that efficiently communicates the tool's purpose with no superfluous words.

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

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

For a simple action with one required parameter and no output schema, the description is minimally adequate. However, it does not specify that the tool returns a success/failure status or any other context about the operation.

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

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

With 100% schema description coverage and only one parameter (taskId), the description does not add any additional meaning beyond what the schema already provides. 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: 'Start working on a Bitrix24 task' and explicitly mentions the outcome ('set status to In Progress'). It distinguishes this from sibling tools like bitrix24_task_complete or bitrix24_task_defer.

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 (to start working), but provides no explicit guidance on when not to use or mention alternatives. For example, it does not clarify that the task must be in a 'New' status first.

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 provided; description fails to disclose behavioral traits like whether it's a partial update, required permissions, error handling, or idempotency. Minimal beyond stating 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?

Single sentence, front-loaded with key action. No wasted words; efficient for what it provides.

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

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

No output schema and no annotations; description is too brief for a mutation tool. Lacks details on response, side effects, and use cases. Incomplete for agent decision-making.

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 schema already describes parameters. Description adds no extra meaning beyond schema, earning baseline 3.

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

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

Description clearly states 'Update an existing Bitrix24 task' with specific verb and resource. Distinct from sibling tools like create, get, list, etc.

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

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

No guidance on when to use this tool vs alternatives like create or complete. No context on prerequisites or exclusions.

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

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

No annotations are present, so the description fully carries the burden of behavioral disclosure. It only states that the tool gets users by ID or filter, but does not mention read-only nature, idempotency, pagination, or behavior when multiple users match the filter. For a data retrieval tool, these are significant omissions.

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, consisting of a single sentence that front-loads the verb and resource. No redundant words or unnecessary details; 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?

Without an output schema, the description should explain the return format (e.g., single object or array). It also does not describe valid filter keys or the behavior when both parameters are provided. The presence of nested objects in the schema is not elaborated upon.

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

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

The input schema has 100% description coverage for both parameters, so the baseline is 3. The description adds no additional meaning beyond what the schema already provides (e.g., it only reiterates the two modes).

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

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

The description clearly states the verb 'Get' and resource 'Bitrix24 user(s)', specifying two modes: by ID or filter. This distinguishes it from sibling 'bitrix24_user_search' which likely performs a different type of user 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 usage for retrieving users by known ID or filter, but it does not provide explicit guidance on when to use this tool versus alternatives like 'bitrix24_user_search' or other user-related tools. No exclusion criteria or prerequisites are mentioned.

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

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

No annotations provided, so the description must disclose behavioral traits. It does not state whether the operation is read-only or has side effects, nor does it mention authentication or rate limits. The description says 'by name' but the schema parameter accepts 'name, email, etc.', causing a slight inconsistency.

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, but it could afford to be slightly more informative without losing conciseness. It is front-loaded and 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?

With no output schema, the description should explain return values or pagination. It does not mention what the tool returns (list of users, IDs, details), nor any limitations or common use cases, leaving the agent underinformed.

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 baseline is 3. However, the description adds minimal value beyond the schema; it only refines the search to 'by name' while the schema already includes broader options. No additional parameter details are provided.

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 'Search', resource 'Bitrix24 users', and criterion 'by name'. It distinguishes itself from sibling tools like bitrix24_user_get (single user retrieval) and bitrix24_im_chat_search (chat 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 on when to use this tool vs alternatives. Does not mention that for a specific user ID one should use bitrix24_user_get, or that the query supports email and other fields beyond name.

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

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

With no annotations, the description fully discloses key behaviors: one row per call, explanation of fields, null status of TRANSCRIPT fields (verified), limitation of REST API vs UI, and authoritative claim for direction/duration.

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?

Well-structured and informative, but somewhat long. Each sentence adds value, so no waste; still, a slightly more compact format could be slightly better.

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

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

No output schema, but the description explains key return fields and provides a complete workflow for understanding a call. Covers filtering, limits, and behavioral notes, making it fully actionable.

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

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

Schema coverage is 100%, but the description adds significant value with concrete examples of filter values, date-bound syntax, and explanation of output fields, exceeding what the schema alone 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?

Starts with a clear verb+resource: 'Get telephony call statistics (Mango Office / Voximplant) — one row per call.' and distinguishes from siblings by providing workflow guidance referencing other tools.

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

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

Explicitly states when to use this tool (to get call stats) and when to use alternatives (bitrix24_crm_timeline_note_get, bitrix24_call_transcribe) for transcript/recording. Provides authoritative guidance on direction/duration.

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

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

No annotations are provided, so the description must fully convey behavioral traits. It states 'list', implying a read operation, but does not disclose pagination, default filtering, return format, or any side effects. A simple 'list' verb is insufficient for 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 sentence with no unnecessary words. However, it is too brief to be informative. Conciseness is good but at the cost of completeness.

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

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

There is no output schema, and the description does not explain return structure, such as fields in each workgroup entry. The tool has one parameter but with an object type, which is covered by the schema. Overall, the description lacks important details for an agent to invoke it correctly.

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

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

The schema description coverage is 100% with the filter parameter having a clear example '{PROJECT: "Y"}'. The description does not add additional meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states 'List Bitrix24 workgroups and projects', which matches the tool name. It specifies the resource (workgroups, projects) and the action (list). Among sibling tools, it uniquely focuses on workgroups, so no confusion. However, it could be slightly more explicit about whether it returns both workgroups and projects or filters.

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

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

No guidance on when to use this tool versus alternatives like task_list, deal_list, or other list tools. The description does not mention context, prerequisites, or exclusions. It assumes the agent knows when to use a workgroup listing.

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