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

There are no annotations, so the description carries the full behavioral burden. It does not state whether the operation is read-only, whether it contacts the WhatsApp service, what the return value looks like, or any side effects. The description only names the check without explaining observable behavior.

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

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

Two short sentences, no filler, and the main purpose is front-loaded. Every word adds value, and the description is appropriately sized for a simple one-parameter tool.

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

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

For a simple one-parameter check tool, the description conveys the core use but lacks expected phone formatting and return result semantics. Since there is no output schema, the agent is left to infer what the outcome of the check looks like. It is adequate but not complete.

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

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

Schema coverage is 0% and the description does not explain the expected phone format (e.g., country code, digits, international format). It simply calls it a 'номер' (number), leaving important parameter semantics undocumented.

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

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

The description states a specific action: checking whether a phone number has WhatsApp. It effectively communicates the tool's core purpose and adds a practical context (check before first sending to a stranger), though it does not explicitly distinguish it from sibling tools.

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

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

The description gives clear when-to-use guidance: 'Проверяйте перед первой отправкой незнакомцу' (check before first sending to a stranger). It does not mention alternative tools or exclusion cases, but the intended context is clear.

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

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

With no annotations, the description carries the full burden. It clearly discloses that the operation removes an event from the queue and identifies the destructive nature. However, it does not mention whether deletion is permanent, whether it can fail for unprocessed events, or any permissions/error behavior.

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

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

The description is a single front-loaded sentence with no filler. It names the action, the target, and the key in one compact statement.

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

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

For a single-parameter, no-output-schema tool, the description is reasonably complete: it names the operation and the input. Still, it lacks guidance on prerequisites, return behavior, and consequences beyond the deletion itself, and there are no annotations to fill those gaps.

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

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

Schema coverage is 0%, so the description must compensate. It adds that receipt_id selects the event to delete and is the queue receipt identifier. This is some semantic value, but it largely restates the parameter name and does not explain how to obtain or validate the receiptId.

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

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

The description states a specific action ('deletes'), a specific resource ('processed event from queue'), and the key used ('by receiptId'). This clearly differentiates it from siblings like receive_notification and the various getters, even without naming alternatives.

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

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

The phrase 'processed event' implies the tool should be used only after events have been processed, but there is no explicit when/when-not guidance or reference to receive_notification as the source of receiptId. Usage context is implied rather than stated.

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

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

With no annotations, the description carries the behavioral burden and does reveal important traits: messages come newest-first, pagination is not supported, and the gateway default count is 100. This goes beyond a generic 'get history' statement, though it stops short of describing response shape or error cases.

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

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

Two short sentences, front-loaded with the most important fact (recent messages newest first) and then the key constraint. No filler or repetition.

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

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

For a simple read tool with only two parameters, the description is largely complete: it covers ordering, pagination limitation, and a default behavior. The clear gap is chat_id semantics and the absence of any return structure, but the core call decisions are adequately supported.

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 0%, so the description must compensate. It meaningfully explains count via the no-pagination note and gateway default of 100, but chat_id is not described at all beyond its name, leaving the required parameter's format and semantics undocumented.

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 resource (chat messages) and operation (reading correspondence), with 'Последние сообщения чата' specifying what is returned. It identifies itself as the 'main tool for reading correspondence,' giving some differentiation from the more targeted sibling tools, though it does not name them explicitly.

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

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

The description gives practical usage context: 'Основной инструмент чтения переписки' tells an agent when to prefer this tool for general chat history reading, and 'Постраничного обхода у GREEN-API нет' clarifies that count is the only way to control volume. However, it doesn't explicitly exclude alternatives like get_last_incoming_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?

With no annotations, the description carries the burden and does add behavioral context: it lists the returned fields and discloses a key limitation (groups are not supported). It stops short of describing error behavior, nullability, or permission requirements, but for a simple read-only getter the description is reasonably 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?

Two short sentences with no filler. The output fields are front-loaded, followed immediately by the essential limitation and sibling alternative.

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

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

For a one-parameter getter with no output schema or annotations, the description covers the main return values and the principal usage boundary. It does not mention failure modes or whether fields can be null, but the overall call context is simple enough that the gaps are minor.

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

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

Schema description coverage is 0%, so the description must compensate. It only indirectly defines chat_id by stating that groups do not work, implying chat_id should identify an individual contact; it does not explain the format or give examples. Some meaning is added, but the sole required parameter is not fully documented.

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 specifies the tool's resource and output: a contact card containing name, avatar, business-account flag, and last online. It also explicitly distinguishes itself from get_group_data by stating groups are not supported, so an agent can reliably select it for individual contacts.

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

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

It gives an explicit exclusion and routing rule: 'Для групп не работает — используйте get_group_data' (does not work for groups — use get_group_data). This clearly tells the agent when not to use this tool and names the alternative sibling directly.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses an important operational trait: the link is temporary and should be downloaded immediately. It does not explicitly state that the operation is read-only, but the retrieval nature is implied.

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

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

Two short sentences with no filler. The core purpose is front-loaded, and the temporary-link warning is a concise, actionable second sentence.

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

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

For a simple two-parameter retrieval tool, the description covers the key scenario, the source of idMessage, the output (a file link), and an important limitation. The only notable gap is the lack of explicit chat_id semantics, but the parameter name makes it inferable.

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 has 0% description coverage, so the description is the main source of parameter meaning. It clarifies id_message as an ID from history for a message with an attachment, but it does not explicitly explain chat_id beyond its self-explanatory name.

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

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

The description clearly states that the tool provides a link to a file from a message with an attachment, identified by idMessage from history. This distinguishes it from sending tools like send_file and send_file_by_url, though it lacks an explicit verb and direct sibling comparison.

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

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

It gives clear context: use this tool when you need a file link from an existing historical message that contains an attachment, passing the idMessage. It does not explicitly name alternatives or exclusion conditions, but the 'from history' and 'with attachment' constraints make the intended usage evident.

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

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

There are no annotations, and the description is a noun phrase rather than a behavioral statement. It does not disclose that the tool is read-only, possible authorization requirements, or error behavior. The 'get' in the title implies a read operation, but the description itself carries little behavioral information.

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 compact and front-loaded with the most important data fields. It earns its place, but it is a fragment rather than a full sentence and would benefit from a verb and slight context.

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

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

For a simple one-parameter getter, listing the returned fields is helpful. However, with no output schema and no annotations, the absence of response structure, error conditions, and sibling routing leaves clear gaps.

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

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

Schema coverage is 0% and the description does not explain the group_id parameter beyond the general group resource. The schema only supplies type 'string' and required status, so an agent does not learn ID format, meaning, or constraints from the description.

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

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

The description 'Данные группы: название, владелец, участники, права' clearly identifies the resource (group) and the key data fields returned (name, owner, participants, rights). It lacks an explicit verb, relying on the tool name for the action, and it does not explicitly distinguish itself from sibling getters.

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

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

Usage context is implied by the resource: call this when group metadata is needed. No when/when-not guidance or comparison with sibling tools such as get_contact_info or get_chat_history is provided.

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

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

No annotations are provided, so the description must carry the full burden. It mentions a required webhook setting, but does not describe failure behavior, side effects, or output format, leaving some transparency gaps.

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

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

The description is two short sentences, with the main action first and no extraneous text. It is well-structured 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?

For a simple read-only tool with one optional parameter and no output schema, the description covers the core purpose, the parameter's meaning, and a prerequisite. It lacks error case details, but the overall context is 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?

The schema has zero description coverage, but the description explains that `minutes` defines the lookback period and mentions the default of 1440 minutes in prose. This compensates for the missing schema description, though minimally.

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

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

The description clearly states the tool retrieves incoming messages across all chats within a time window, and explicitly mentions the use case of seeing new messages without iterating chats. This distinguishes it from per-chat history tools among siblings.

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

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

It provides a specific when-to-use scenario: to see what's new globally. It also notes a prerequisite (incomingWebhook must be enabled), but does not explicitly name alternative tools for contrasting cases, so it falls short of a full 5.

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

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

With no annotations, the description carries the full transparency burden. It discloses the data scope and that delivery status is included, but it does not state read-only behavior, result ordering, pagination/limits, or whether the returned structure contains anything beyond the messages and their statuses.

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

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

The description is one compact sentence that front-loads the main resource (outgoing messages) and then adds the two relevant modifiers: all chats and the time window with delivery status. There is no filler or unnecessary repetition.

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

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

The core selection criteria are present, but because there is no output schema and no annotations, the description leaves out practical invocation details such as result ordering, maximum result count, and the exact fields returned for each message. It is adequate for basic selection but not fully 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 schema only describes `minutes` as an integer with a default of 1440, while the description adds the key semantic that it is the trailing window length for the query. This meaningfully clarifies how to use the parameter, though it could also note bounds or an effective maximum.

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

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

The description clearly identifies the resource as outgoing messages across all chats, scoped to the last `minutes` minutes and including delivery status. The qualifier 'Исходящие' (outgoing) distinguishes it from the sibling get_last_incoming_messages, and the tool name supplies the 'get' verb.

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 intended usage is implied: call this when an agent needs recent outgoing messages with delivery status across all chats. However, it does not explicitly state when not to use it or which sibling to prefer for incoming messages, per-chat history, or other filtered queries.

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

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

No annotations are provided, and the description does not explicitly state that the tool only reads settings and has no side effects. The 'get' in the tool name suggests read-only behavior, but the description itself could be more explicit about what it returns and that it does not modify anything.

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

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

The description is two sentences long and contains only relevant information: the scope of settings and an important operational caveat. No filler or redundant wording is present.

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 mentions instance settings and notification flags, and gives a useful related warning, but it does not describe the return structure or enumerate the settings that will be present. Since there is no output schema, a bit more detail about what the caller receives 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 tool has zero parameters and the schema coverage is 100%, so there are no parameter details for the description to clarify. The baseline of 3 applies because there is no additional parameter meaning to add.

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

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

The title 'Get Settings' combined with the description 'Instance settings, including notification flags' makes the tool's purpose clear. It identifies the resource and a key category of settings, though the description itself is a noun phrase rather than an explicit action statement.

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

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

The description gives a practical warning: without `incomingWebhook: yes`, incoming message logs and read receipts do not work. This implies when checking or troubleshooting settings might be useful, but it does not explicitly state when to use this tool versus alternatives like `set_settings`.

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

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

With no annotations, the description carries the full burden. It does disclose meaningful behavioral information by defining each state, including that blocked means banned and notAuthorized requires re-scanning a QR code. However, it does not explicitly state that this is a read-only/no-side-effect operation or describe the return format.

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 compact and well structured: a short purpose statement followed by a clear list of possible state values and their meanings. Every sentence adds useful information without unnecessary padding.

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 zero-parameter status-check tool with no output schema, the description adequately explains the three possible outcomes. It could be even more explicit about the expected return representation, but the state values and their implications are sufficiently covered.

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

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

The tool has zero parameters, so the baseline is 4. No parameter documentation is needed, and the description does not introduce any parameter-related ambiguity.

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

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

The description clearly states that the tool returns the status of a GREEN-API instance and enumerates the possible state values. It does not explicitly differentiate from sibling tools, but the resource and verb are clear.

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

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

There is no guidance on when to use this tool versus alternatives. The description explains what each returned state means but does not say when a caller should check state, such as before sending messages or after a connection failure.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds a meaningful, non-obvious behavioral detail: the list may lag up to 5 minutes on the WhatsApp side, and an empty response after connection is expected rather than an error. It does not cover all possible behaviors, but the timing caveat is substantive.

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

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

The description is two compact sentences with no wasted words. The first sentence states the resource and output fields; the second adds the single most important behavioral caveat. It is front-loaded and easy to scan.

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

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

For a low-complexity read tool with no required parameters, the description covers core purpose and a key timing caveat, which would allow a basic call. However, the lack of parameter explanations—especially count—and the absence of any comparison to sibling list/detail tools leave meaningful gaps for an agent deciding how to invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description does not mention either parameter. The 'only' enum is documented in the schema, but the 'count' parameter is only described as integer/null with no meaning, bounds, or behavior explained, so an agent cannot reliably know what values are meaningful.

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

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

The description clearly identifies the resource as chats and contacts known to the instance, and even lists the returned fields (id, name, type). Though phrased as a noun ('Список...') rather than an explicit verb, it is unambiguous about what the tool produces and is broad enough to be distinguished from siblings like get_chat_history or get_contact_info.

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 useful usage context: the WhatsApp-side list refresh can take up to 5 minutes, and an empty response immediately after connection is normal and should be retried later. However, it does not explicitly state when to prefer this tool over related alternatives such as get_contact_info or get_group_data, nor does it mention any exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses a significant side-effect: the sender sees two blue checkmarks ('Собеседник увидит две синие галочки'), making this a noticeable action. This is genuinely informative beyond merely stating 'marks as read'.

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

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

Two compact sentences: first states the action and scope rule, second gives the side-effect warning. No filler or redundant phrasing.

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 state-mutation tool, the description covers the action, the optional scope, and user-visible consequences. It does not discuss return values or error handling, but these are less critical given the tool's simplicity and lack of output schema.

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

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

The schema gives no descriptions (0% coverage), but the description explains the functional meaning of id_message: omitting it marks the whole chat. chat_id is not explicitly defined, though its meaning is obvious from the name and context.

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

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

The description uses a specific verb and resource ('Отмечает чат прочитанным' – marks chat as read) and clarifies two operational modes (whole chat vs specific message). This clearly distinguishes it from sibling tools, none of which handle read-state mutation.

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

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

It gives clear guidance on the id_message parameter ('Без id_message — весь чат'), defining when to mark the whole chat vs a single message. It does not explicitly name alternative tools, but no sibling tool offers this action, so the context is sufficient 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?

With no annotations provided, the description carries the full burden and does so excellently. It discloses FIFO behavior, 24-hour retention, timeout-driven `null` returns, the 5–60 second range, and the critical fact that a received event is not consumed until `delete_notification` is called.

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 tight sentences, with no filler. The core action is front-loaded, followed by return behavior and the necessary ack instruction. Every sentence carries essential information.

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

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

For a low-complexity tool with one optional parameter and no output schema, the description is complete: what the tool returns, when it returns `null`, how long events are kept, how to acknowledge them, and the consequence of not acknowledging. An agent has enough to call it correctly.

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

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

Schema coverage is 0%, so the description must explain `receive_timeout`, and it does: it defines the value range (5–60 seconds) and its behavioral effect on the call. This adds significant meaning beyond the bare schema type and default.

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

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

The description clearly states a specific operation: receiving one event from an incoming FIFO queue, with return values `receiptId` and `body` or `null` on timeout. It distinguishes itself from siblings by emphasizing queue semantics, FIFO order, and the explicit tie to `delete_notification` for consumption.

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

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

It gives clear operational context: poll the incoming queue, wait up to `receive_timeout`, and call `delete_notification` after processing to avoid re-reading the same event. It does not explicitly contrast with alternatives like `get_last_incoming_messages`, but the queue/ack model makes the intended use 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?

没有注解，因此描述承担了行为透明度的全部责任。它明确披露了操作不可逆，建议请求确认，并说明文件大小限制为100 MB。这些是有价值的操作背景，尽管没有涵盖权限或失败模式等细节。

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?

两句话，简洁且无冗余。第一句陈述核心操作，第二句提醒不可逆性并请求确认。所有内容都有具体价值，结构清晰。

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?

对于一个包含4个参数（其中2个必需）的工具，描述过于简短。它没有解释参数、没有给出与send_file_by_url的使用区别，也没有提供关于输出或失败情况的任何信息。关键上下文缺失。

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?

模式描述覆盖率为0%，而描述完全没有解释任何参数（path、caption、chat_id、file_name）。仅说"发送本地文件"，代理无法从描述中获得正确填充参数所需的含义，因此完全未弥补架构中的信息缺失。

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?

描述以明确的动词"Отправляет"开头，并指出了具体资源"локальный файл"（本地文件）和目的地"в чат"。还提供了大小限制（100 MB），这有助于区分该工具与通过URL发送文件的兄弟工具send_file_by_url。

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?

描述没有提供何时使用此工具以及何时使用替代工具的明确指导。它只是将行为与send_message比较，并提到不可逆性，但未说明与send_file_by_url的区别或适合使用此工具的条件。

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

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

There are no annotations, so the description carries the burden. It does disclose a meaningful non-obvious behavior: the file is sent directly from the public link without being downloaded to this machine. But it omits other behavioral context such as failure modes, URL accessibility requirements, return value, or side effects beyond the obvious send.

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

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

A single, front-loaded sentence that immediately communicates the core action and the key behavioral nuance. There is no filler, repetition, or unnecessary detail.

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

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

With no annotations and no output schema, the description still leaves the agent guessing about return values, error handling, whether the URL must be publicly reachable from the server, and how chat_id/file_name/caption are used. It is adequate for recognizing the tool, but not for predicting the full behavior of a call.

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

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

Schema description coverage is 0%, and the description only clarifies url_file by calling it a public link. It does not explain chat_id, file_name, or caption, nor their relationships. With 4 parameters and no schema-level descriptions, the definition should compensate much more than it does.

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

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

The description states a clear action ('sends a file') and the specific delivery mechanism ('by public link'). It also adds a distinguishing behavioral detail ('without downloading it to this machine') that separates it from the sibling send_file, which might copy the file locally before sending.

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

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

The description implies when to use the tool: when the file is available via a public URL and should not be downloaded to the host machine. However, it never explicitly names an alternative or states when not to use it, so the agent must infer the routing from the phrasing and sibling list.

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

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

Explicitly discloses that the action is irreversible and visible to the recipient, and mentions the return value. With no annotations present, this description fully covers the important behavioral side effects.

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 brief and focused, consisting of two clear sentences with no redundant or misleading content. It is well-structured 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?

While the core purpose and confirmation warning are present, the description omits details about optional parameters and does not fully compensate for the lack of an output schema. An agent would not know how to use link_preview or quoted_message_id correctly.

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

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

Schema description coverage is 0%, and the description only mentions 'text' and 'idMessage'. It does not explain chat_id, message, link_preview, or quoted_message_id, leaving most parameters semantically unexplained.

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 sends text to a chat and returns an idMessage, distinguishing it from file-sending siblings. The verb 'sends' and resource 'chat' are specific and unambiguous.

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

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

Provides some usage guidance by instructing to ask for user confirmation before calling, and implies use for text messages. However, it does not explicitly mention when to prefer this tool over alternatives like send_file or send_file_by_url.

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

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

With no annotations, the description carries the full burden. It discloses the critical side effect that the instance restarts and can take up to 5 minutes, plus the persistence-related webhook setup. It doesn't mention response format or error conditions, but the restart warning is substantial transparency for a mutation tool.

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

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

The description is compact: two short sentences plus a JSON example. The primary action and side effect are front-loaded, and the usage scenario follows. No filler or redundancy.

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

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

For a simple one-parameter tool with no annotations and no output schema, the description covers the essential context: what it does, when it's needed, what to pass, and what side effect to expect. It doesn't describe success/error responses, but that's a minor gap for this low-complexity 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 0% and the schema only defines a generic 'settings' object with additionalProperties. The description compensates by giving a concrete, realistic JSON example with keys like incomingWebhook and outgoingMessageWebhook, which tells the agent what values are expected. It could be more exhaustive, but the example adds significant 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 opens with a clear verb and resource: 'Меняет настройки инстанса' (changes instance settings). It distinguishes itself from the sibling get_settings by defining the write counterpart, and the concrete webhook example further clarifies the intended scope.

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

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

States exactly when to use the tool: 'нужен в основном один раз при подключении' (needed mainly once at connection), and explains the consequence of not using it (empty incoming/outgoing logs). This gives an agent actionable context for selecting and invoking the tool during setup.

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