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

With no annotations provided, the description carries the full burden. It lists the kinds of information returned (connection, auth, read-only, user), but does not explicitly state that the operation has no side effects or how it behaves when disconnected. This is adequate for a status tool but not comprehensive.

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 the core concept front-loaded ('Status of connection and login') followed by a compact list of reported states. Every word earns its place, and the line breaks improve readability.

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 tool with an output schema, the description covers all relevant reported dimensions and implies a read-only nature. An explicit note that no state changes occur would be a minor enhancement, but nothing essential is missing.

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

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

The tool has zero parameters and an empty properties object, so there is nothing for the description to add about parameter semantics. The baseline of 4 applies.

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

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

The description clearly states the resource (connection and login status) and enumerates the exact components: client connection, account authorization, read-only mode, and current user. This is specific enough to distinguish it from account tools like get_me.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as get_me, login_*, or logout. The word 'status' implies a checking use case, but no alternatives or exclusion conditions 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It reveals a meaningful side-effect distinction: revoke=true affects all participants, while revoke=false only affects the caller's view. This goes beyond the raw schema and tool name, though it does not mention permission requirements or irreversibility.

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 short and front-loaded with the action, followed by the key parameter behavior. Every clause earns its place, with no filler or repetition of schema information.

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

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

The core deletion behavior and revoke modes are covered, and since an output schema exists, return-value details are not required. However, important operational context is missing: no mention of how to obtain message_ids, whether deletion is limited to the user's own messages, or what permissions are needed for revoke=true. This leaves meaningful gaps for an agent attempting a real deletion.

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 adds clear meaning for revoke, mapping boolean values to concrete behavior, but provides little extra semantics for chat and message_ids; it relies on their self-explanatory names. This is a partial but not complete compensation for the missing schema descriptions.

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

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

The verb 'Удалить' makes the core action explicit, and 'сообщения' identifies the resource. The revoke clause adds two distinct modes (delete for everyone vs. only for self), which fully clarifies the purpose without needing sibling differentiation since no other delete tool exists.

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

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

The description does not name alternatives, but no deletion sibling is present, so tool selection is unambiguous. It does provide conditional usage guidance for the revoke parameter: use true to delete for everyone and false to delete only from the user's side, which tells the agent how to choose behavior based on intent.

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 usefully discloses the default download directory and that the tool returns a path, which goes beyond the bare schema. However, with no annotations available, it omits important behavioral details such as error handling for missing attachments, overwrite behavior, and whether directories are created.

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 front-loaded with the core action. Every sentence contributes meaningful information: what it does, what it returns, and where files go by default.

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 basics are present: required parameters are indicated by the schema, and the return value is noted. Still, the lack of annotations and absence of failure-mode or precondition information leaves the description only minimally viable for correct invocation in edge cases.

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

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

Schema description coverage is 0%, so the description must compensate, but it only clarifies the out_dir default via TELEGRAM_MCP_DOWNLOAD_DIR. The semantics of chat and message_id are left entirely to their schema titles, with no format, resolution, or usage context 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 operation: download a message attachment to a local file and return the path. This distinguishes it from siblings like send_file (uploading) and get_message (retrieving message data).

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

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

No guidance is given about when to use this tool versus alternatives such as get_message or send_file. Prerequisites like the message actually containing an attachment are not 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 does state that the message must be the user's own ('своё'), which is a useful constraint, but it fails to disclose what happens on failure, permission requirements, whether edits are limited in time, or how parse_mode/link_preview affect the edit. For a mutation tool, this is a significant gap.

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 zero wasted words. It is appropriately compact for stating the core operation, though it is terse to the point of under-specification. Still, as a concise phrasing, it earns a high score.

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

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

Given a 5-parameter mutation tool with no annotations and 0% schema description coverage, the description is far from complete. It does not explain required parameters, the meaning of parse_mode or link_preview, any side effects, or error conditions. The presence of an output schema covers return values, but the description leaves critical decision-making context to the agent's guesswork.

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 for undocumented parameters. It only clarifies the role of 'id' (message_id), while ignoring chat, text, parse_mode, and link_preview. The schema provides names and defaults but no descriptions, and the tool description adds little beyond the word 'id'.

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

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

The Russian description 'Изменить своё сообщение по id.' clearly identifies a specific verb ('edit'), a resource ('message'), and an identifier requirement ('by id'). It also adds the scope restriction 'своё' (your own), which helps distinguish from operations like send_message or delete_messages. However, it does not explicitly name any sibling tool or contrast itself, so it falls short of full differentiation.

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

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

No guidance is provided about when to use this tool versus alternatives such as send_message or delete_messages. The description does not mention prerequisites (e.g., must have already sent the message), restrictions, or context where editing is appropriate. There is no exclusion or alternative 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 are provided, so the description carries the full behavioral burden. It usefully discloses that drop_author=true removes the 'Forwarded from' header and makes the message appear as a normal message. However, it does not mention permissions, error behavior, or what happens with invalid 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?

The description is two short sentences with no filler. The main action is front-loaded, and the second sentence adds meaningful detail about the drop_author flag without 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?

The description covers the core action and the key behavioral flag, and an output schema is present. Still, it lacks detail about required parameter semantics, chat identifier format, and edge cases, making it adequate but incomplete for a mutation tool with no annotations.

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 explains only drop_author; from_chat, to_chat, and message_ids remain undocumented beyond their names. In particular, the expected format of chat identifiers is unclear, leaving required parameters underspecified.

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: 'forward messages from one chat to another.' It clearly conveys the core action and is distinguishable from siblings by its narrow forwarding function, though it does not explicitly name an alternative such as send_message.

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

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

The usage is implied by the action itself: use this when existing messages need to be forwarded to another chat. However, there is no explicit guidance about when not to use it or how it compares to alternatives like send_message or edit_message.

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 disclosure burden. It does add behavioral context by stating that bio/about is returned 'if available' and by specifying accepted identifier forms including id, @username, t.me link, phone, or 'me'. It does not mention potential errors, authorization requirements, or behavior for unsupported references.

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 information-dense: the first sentence covers returned fields and the second covers acceptable input forms. There is no filler, repetition of schema details, or unnecessary elaboration.

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

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

For a single-parameter lookup tool with an output schema, this description covers the essential invocation details: what data is returned and what forms the chat argument can take. It lacks explicit usage differentiation and authorization/error context, but is otherwise sufficient for an agent to call 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?

Despite 0% schema description coverage, the description fully explains the only parameter 'chat' by enumerating accepted formats: id, @username, t.me link, phone, or me. This adds substantial meaning beyond the bare schema property name 'Chat'.

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

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

The description names a specific operation and outcome: retrieving information about a chat/user/channel with fields such as id, type, username, participant count, and bio. It is clear about what the tool does, but it does not explicitly distinguish itself from siblings like resolve_chat, so it stops short of full differentiation.

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 this tool — when full chat metadata is needed — by listing returned fields and accepted identifier forms. However, it provides no explicit when-to-use guidance, exclusions, or comparisons with alternatives such as resolve_chat or list_dialogs.

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 behavioral burden. It only states that folders have ids and names; it does not explicitly say the call is read-only, whether it requires login, or how it behaves when there are no folders. The 'get' prefix implies retrieval, but the description itself is minimal.

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

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

The description is extremely short and contains no filler; the core point about folders and their id/name fields is immediately visible. It leans a little toward under-specification rather than being a well-rounded sentence, but it wastes no words.

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

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

The tool is simple, has no parameters, and an output schema exists, so return-value details are not the description's responsibility. The main gap is contextual: it does not say when to use this instead of sibling tools or whether authentication is required, which an agent needs to invoke it at the right time.

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 an empty schema, so there is nothing for the description to clarify. The no-parameter baseline is 4, and the description does not need to compensate for any undocumented arguments.

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

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

The description identifies the specific resource ('folders of the account') and the exposed fields ('their id and names'), which is enough to distinguish this from siblings like list_dialogs or get_chat. It is phrased as a noun fragment rather than an explicit verb phrase, but the tool name 'get' supplies the operation.

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

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

There is no guidance about when to use this tool versus alternatives such as list_dialogs or get_chat. It also does not mention prerequisites like authentication, so an agent has to infer the appropriate context from the tool name alone.

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

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

With no annotations, the description carries the behavioral disclosure burden. It communicates that the operation is a read-only listing of the account's contacts, which implies no destructive side effects. It does not mention authentication, data freshness, or potential errors, but those are secondary for such a straightforward getter.

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

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

The description is one short sentence with no filler, and the core meaning is front-loaded. It adds the useful clarifying context 'Telegram address book' without 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 parameterless read-only tool with an output schema available, the description is largely complete: it states what is returned and whose data it returns. It could add an explicit statement about requiring an authenticated account, but that is inferable from 'account contacts.'

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 input schema fully specifies the interface (100% coverage vacuously). Per the baseline for 0-parameter tools, the description needs to add no parameter detail, and the 4 is appropriate.

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

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

The description identifies the resource as the account's contacts/Telegram address book, which clearly distinguishes it from sibling tools like get_chat or get_participants. However, it is phrased as a noun phrase rather than an explicit verb+resource statement, and it doesn't directly name alternatives.

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

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

Usage context is implied by the name and description: call this when the account's contact/address book list is needed. There is no explicit guidance about when not to use it or which alternative to prefer, but the tool is simple enough that this is a minor gap.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It clearly explains the ordering (newest first), pagination direction using before_id, and the from_user filter. It does not explicitly state that the operation is read-only, but the semantics strongly imply a non-mutating retrieval.

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 front-loaded: it states the core resource and ordering first, then explains the two nuanced parameters. Every sentence contributes meaning, with no filler or redundancy.

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

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

The description covers the key behavioral semantics needed to call the tool correctly, and an output schema exists to handle return-value documentation. It lacks explicit alternative routing and read-only/side-effect language, but for a straightforward history retrieval tool 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?

Schema description coverage is 0%, so the description must provide parameter meaning. It successfully explains the two non-obvious parameters: before_id as a pagination cursor into older messages, and from_user as a sender filter. The remaining parameters chat and limit are reasonably self-evident from their names and types.

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 and resource: retrieving chat messages ('Сообщения чата') with a specific ordering ('новые первыми'). It is distinguishable from siblings like get_message (single message) and search_messages (search), though it does not explicitly name those alternatives.

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

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

The description implies its use for reading chat history and explains pagination/filtering behavior, but it does not explicitly say when to prefer this tool over search_messages, get_message, or list_dialogs. There is no when-not-to-use guidance or named 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 carries the full burden of behavioral disclosure. It does not explicitly state that the operation is read-only, whether authentication is required, or what errors might occur. The noun-phrase style conveys the resource but not the actual 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 short phrase with no filler, redundancies, or unnecessary detail. It is appropriately sized for a zero-parameter profile endpoint.

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 presence of an output schema, and zero parameters, the description is nearly complete for basic invocation. It could slightly improve by stating that it returns the profile, but an agent can correctly infer the operation and call it with no arguments.

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, which earns a baseline of 4. The description adds context by clarifying that the relevant account is the currently logged-in one, which is meaningful but not parameter-related.

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

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

The description identifies the resource as the profile of the currently logged-in account, which clearly distinguishes it from sibling tools focused on chats, messages, or authentication flows. It lacks an explicit verb like 'returns' or 'fetches', so it is clear but not fully specified.

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

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

No guidance is provided about when to use this tool versus alternatives such as auth_status, which could be confused for a related operation. The intended context is implied by the phrase 'current logged-in account', but no explicit exclusions or conditions are stated.

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

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

With no annotations provided, the description carries the burden of conveying behavior. It explicitly notes that attachment details are included when present, which adds useful expectation-setting beyond the bare operation. The name and wording make clear this is a read-only retrieval, so no destructive side effects are 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?

The description is one compact, front-loaded sentence with no filler. It communicates the core operation and the attachment-detail nuance efficiently.

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

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

For a simple two-parameter retrieval tool, the description is mostly sufficient, and an output schema is available to explain return values. The only notable gap is the undocumented format of the chat parameter, which an agent may need to resolve before calling this tool.

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

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

Schema description coverage is 0%, so the description must compensate for vague parameter semantics. It clarifies that message_id refers to the message id, but it does not explain what 'chat' is or how it should be formatted (id, username, etc.). The chat parameter remains underspecified for reliable invocation.

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 exactly what the tool does: retrieves one message by id and includes attachment details if present. This clearly distinguishes it from siblings like get_history (list messages) and search_messages (search), since it targets a single known message id.

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 'by id' implies the agent should use this when it already has a specific message id, but there is no explicit guidance about when to prefer alternatives like get_history or search_messages. No exclusions or 'when not to use' information is provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It usefully discloses that Telegram does not return participants completely for large channels, which is valuable context. However, it does not mention pagination, required authentication, rate limits, or any other operational behaviors.

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

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

The description is two concise sentences with no filler. The core purpose is front-loaded, the query parameter is explained, and the Telegram limitation is stated in an efficient way.

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

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

The tool is simple and has an output schema, so return values need no extra explanation. The main gaps are the lack of semantics for chat and limit, and the absence of guidance on pagination or large-channel behavior beyond the stated limitation. The description is adequate but not fully complete for autonomous agent invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the query parameter as a filter by name/@username, which adds real meaning beyond the schema. However, chat and limit parameters are not semantically explained; chat is only implied by 'group/channel' and limit is left to the schema 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 identifies the resource as participants of a group/channel and the operation as retrieving them. It distinguishes the tool from siblings like get_chat and get_contacts by focusing on group/channel membership, but it does not explicitly name those alternatives.

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

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

The description implies the tool is for fetching group/channel participants and mentions a query filter, but it gives no explicit guidance on when to use this tool versus sibling tools like get_chat, get_contacts, or search_public. There are no exclusions or alternative tool references.

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

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

There are no annotations, so the description must carry the full burden. It only states the join action and link formats, with no mention of side effects, authentication requirements, failure modes for invalid links, or behavior when already a member. This is a meaningful transparency gap for a mutating operation.

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

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

The description is a single compact sentence that front-loads the core purpose and immediately provides the essential parameter guidance. There is no redundant or filler content.

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

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

The tool is simple with one parameter and an output schema, so the description covers the basic invocation. However, it omits behavioral and environmental context such as the need for an authenticated session and error handling for invalid or expired invitation links. These are not covered by annotations, leaving some gaps.

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

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

The input schema provides only a bare 'link' string with 0% schema description coverage. The description compensates thoroughly by specifying all accepted formats: @username, t.me/name, t.me/+hash, and t.me/joinchat/hash. This gives the agent precise guidance for constructing the parameter value.

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

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

The description clearly states the action (joining) and the resource (group/channel), and enumerates the accepted link formats (@username, public t.me/name links, and invite links). This makes it immediately distinguishable from sibling tools like leave_chat or resolve_chat.

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 user wants to join a chat using a supported link. However, it does not explicitly mention alternatives or conditions where this tool should not be used, such as distinguishing it from resolve_chat for mere lookup.

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

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

With no annotations, the description carries the behavioral burden. It makes clear this is a mutating membership action and adds the explicit guardrail that confirm=true is required, going beyond the schema's default false. It stops short of disclosing permanence or rejoin consequences, so it is not a 5.

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

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

Three short sentences, front-loaded with the action, and every sentence earns its place: purpose, confirmation requirement, and chat format. There is 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 two-parameter tool with an output schema, the description supplies the key operational facts: target format and confirmation requirement. It is complete enough for invocation, though the choice against join_chat is left implicit and post-leave effects are not described.

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 explains both parameters meaningfully: chat accepts an id, @username, or link, and confirm must be true. This adds substantial value beyond the bare schema titles.

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 specific verb and resource: 'Покинуть группу/канал' (leave group/channel), clearly distinguishing this from sibling actions like join_chat or logout. It is not a tautology of the tool name because it narrows the target to groups/channels.

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

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

The description implies the use case: call it when you want to leave a group or channel. It also states the operational requirement that confirm=true must be set, but it does not explicitly mention alternatives or when not to use this tool. This is adequate but not fully 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?

With no annotations, the description carries the disclosure burden. It does reveal important behavior: results are sorted newest first, include unread and last-message data, and can be scoped to the archive via archived=true. However, it does not explicitly state that the operation is read-only or mention pagination/response behavior beyond what the output schema may convey.

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

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

The description is concise and front-loaded: the core result semantics come first, followed by the two non-obvious filters. No filler or repetition, though limit is omitted. Each sentence earns its place.

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

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

The description adequately covers the primary call semantics for a simple list tool with an output schema. However, it does not mention pagination/limit behavior or clarify how this tool relates to get_chat_folders and search_public, leaving a moderate gap in contextual guidance.

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

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

Schema description coverage is 0%, so the description must compensate. It does clarify archived (archive folder) and query (case-insensitive substring), which is helpful beyond the schema's bare titles. But limit is not explained at all, leaving one of the three parameters semantically under-specified.

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 (dialogs/chats) and what is included: unread count, last message, and newest-first ordering. It distinguishes itself from search-oriented siblings by framing itself as a chronological listing, though it does not explicitly name alternatives.

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

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

No guidance is given about when to use this tool versus siblings like get_chat_folders, search_public, or search_messages. The description explains what the tool returns and how filters behave, but does not state exclusions or preference conditions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explains the three calling variants and the 2FA sequence, which is substantive. It does not mention session side effects or error behavior, but for a login-completion step this 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?

Three short sentences with front-loaded intent and no filler. Every sentence conveys a distinct call scenario, and the ordering mirrors the logical authentication flow.

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

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

The tool has only two optional parameters and an output schema, so the description covers the main input space well. It does not explicitly state the prerequisite that login_send_code or login_qr must be invoked first, though this is inferable from the sibling tools and the wording 'после сканирования'.

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 explain the parameters, and it does. It defines 'code' as coming from a Telegram message, 'password' as the 2FA step after code, and clarifies that a QR login requires no arguments. This adds meaning well beyond the bare optional schema fields.

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 specific verb and resource, 'Завершить вход' (complete login), and clearly identifies the tool as the completion step for authentication. It differentiates itself from siblings like login_send_code and login_qr by describing distinct call modes: code-based, password/2FA-based, and QR-based.

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 concrete usage instructions: pass the code from Telegram, follow with password if 2FA is enabled, or call with no arguments after a QR scan. It does not name alternative tools or exclusion conditions explicitly, but the context is clear enough for an agent to know when this step applies.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It does disclose the return value and the necessary follow-up action, which is helpful. However, it omits such details as link expiry, whether starting QR login invalidates other pending login attempts, or what error conditions may arise, leaving only a moderate level of 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 entire description is one compact sentence that covers the action, the output format, the manual user step, and the next tool to call. Each clause adds necessary information and there is 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 zero-parameter tool that has an output schema, the description is nearly complete: it explains the returned link, the required user action, and the follow-up call. Minor gaps such as failure modes and link expiration are not critical for successfully invoking the tool.

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

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

The tool takes zero parameters, so the baseline is 4. The description correctly notes that the subsequent login_complete() call takes no arguments, though that pertains to a sibling tool. No parameter-specific information is needed here because the schema is already empty.

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 the specific action 'Начать вход по QR-коду' (start login via QR code) and immediately states the concrete output: 'вернёт ссылку tg://login' (returns a tg://login link). This clearly differentiates the tool from sibling login tools like login_send_code and login_complete by positioning it as the QR-code initiation step.

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 step-by-step instructions: scan the returned link with an already-authenticated Telegram via Settings → Devices → Connect device, then call login_complete() without arguments. It provides clear context but does not explicitly state when to prefer QR login over login_send_code or 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?

There are no annotations, so the description carries the disclosure burden. It does reveal the primary side effect — Telegram will send a code — and that this is an initiating step rather than a completed login. It does not mention rate limits, code expiration, or the fact that repeated calls may invalidate previous codes, but the core behavior is disclosed.

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

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

Two short sentences contain all necessary information: purpose, parameter format, example, and next step. There is no filler or redundant restating of the tool name.

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

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

For a simple single-parameter login step with an output schema present, the description is complete. It tells the agent what happens, how to format the input, and what to call next, which is everything needed to invoke this tool correctly.

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

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

The input schema only says 'phone' is a string. The description adds essential semantic meaning: the phone must be in international format and gives a concrete example (+79991234567). This fully compensates for the otherwise absent schema-level description.

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

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

The description states a specific verb-resource pair: it is the first step of phone-number login that makes Telegram send a code. This clearly distinguishes it from login_complete and login_qr, which are the natural siblings, without needing to inspect the schema.

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

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

It explicitly says this is the first step and instructs the agent to call login_complete(code=...) next. This is clear when-to-use guidance within the phone login flow, though it does not explicitly contrast with login_qr or explain when phone login is preferable.

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 behavioral disclosure burden. It clearly discloses that login is revoked and the local session is deleted, signaling destructive side effects. It could elaborate on remote-session consequences, but the key behavior is 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 front-load the action and consequence, then explain the required parameter. Every sentence earns its place with 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?

This is a one-parameter tool with an output schema, and the description covers the sole behavioral requirement (confirm=true) plus side effects. An agent has everything needed to invoke it correctly.

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

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

The schema only provides a boolean confirm with a default of false and no description, so 0% schema coverage. The description adds the crucial semantic that confirm must be true because logging out revokes authorization, fully compensating for the schema gap.

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

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

Description names a specific action (logout from Telegram account) and a concrete side effect (deleting the local session), which unambiguously distinguishes it from auth_status and login_* siblings. The verb and resource are clear and non-tautological.

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 that confirm=true is required because logout cancels the userbot authorization. It does not discuss alternatives or when-not-to-use, but no sibling tool performs the same action, so this is reasonable 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 the burden of behavioral disclosure. It transparently covers the core behavior and the max_id semantics, but it does not mention authorization requirements, reversibility, or side effects on unread counts.

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

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

The description is a single compact sentence that leads with the action and packs the important scope distinction without filler. Every part contributes to understanding the tool.

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

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

For a simple two-parameter tool, the description covers the core invocation semantics, and an output schema exists so return values need not be described. Still, the lack of usage context, alternatives, or behavioral side effects leaves some gaps for an agent deciding when to use it.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics to max_id by clarifying the inclusive boundary and the 'или весь' whole-chat option when max_id is null. The chat parameter is self-evident from context but receives no additional semantic detail.

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 ('Отметить чат прочитанным') and the resource (chat), and adds the scope detail 'до max_id включительно или весь'. This clearly identifies what the tool does, 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 implies usage by explaining the two modes: mark up to a specific max_id or mark the entire chat. However, it does not provide explicit when-to-use or when-not-to-use guidance, nor does it reference alternative tools from the sibling list.

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

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

Annotations are absent, so the description carries the full burden. It does disclose a meaningful behavior: notify=false suppresses notifications to participants. However, it does not mention other relevant effects, such as whether pinning overwrites an existing pinned message or requires special permissions.

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 stating the action, immediately followed by the key parameter caveat. No filler or redundancy; 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?

An output schema exists, so return values need not be described. The description covers the main behavioral flag but omits important context like prerequisites (e.g., permissions), whether the pin replaces an existing one, and when to use this tool versus unpin_message. Adequate for a simple mutation, but 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 description coverage is 0%, so the description must compensate. It explains the notify parameter explicitly. The chat and message_id parameters remain undocumented in the description, though their names are fairly self-evident in context. Partial compensation.

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 verb and resource: 'Закрепить сообщение' (pin message), which is specific and easily distinguished from siblings like unpin_message by opposite action. However, it does not explicitly name or differentiate itself from that sibling within the text.

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

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

No guidance is provided on when to use this tool versus alternatives such as send_message or unpin_message. The only usage-related hint is about the notify parameter, which is a parameter behavior note rather than tool-selection guidance.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It states what the tool resolves and that it returns id, type, and main fields, but it does not mention authentication requirements, error behavior, network side effects, or whether the operation is read-only. For a resolver with no annotation safety hints, this is a noticeable gap.

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 filler. It front-loads the primary action ('resolve a reference into a Telegram entity'), then lists input formats and output contents. Every clause 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 one-parameter tool with an output schema present, the description is largely complete: it names accepted inputs and the kind of result returned. It lacks explicit alternative routing and behavioral caveats, but those are covered by other dimensions. The presence of an output schema reduces the need to explain return values in detail.

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 carry the meaning of the single 'query' parameter. It does this thoroughly by enumerating the accepted input formats: @username, phone, t.me link, numeric id, or 'me'. This adds substantial value beyond the raw schema, which only provides a type of string.

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 'resolve' and names the resource: a Telegram entity. It explicitly lists the accepted input forms (@username, phone, t.me link, numeric id, or 'me'), making the tool's purpose clear. It does not explicitly contrast itself with siblings like get_chat or search_public, but the resolution behavior is distinct enough to avoid confusion.

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

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

The description implicitly conveys when to use the tool: when you have a reference like @username, a phone number, a t.me link, an id, or 'me' and need the underlying entity. It does not state when not to use it, nor does it mention alternatives such as get_chat or search_public, so the usage guidance is implied rather than explicit.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It usefully reveals that behavior changes based on the presence of chat and that from_user is coupled with chat. However, it does not disclose whether authentication is required, how limit behaves, what happens if from_user is used without chat, or any result-ordering/pagination 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 compact and front-loaded: the first sentence states the purpose, the second explains the key scoping behavior. No filler words or redundant restatements of the schema are 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?

An output schema exists, so return values do not need to be described. Still, the description is incomplete as a standalone guide: it omits limit semantics, the from_user-without-chat edge case, and any guidance distinguishing this tool from search_public. These are meaningful gaps for an agent selecting and invoking 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%, so the description must compensate. It adds meaning for chat (global vs scoped) and partially for from_user (works with chat), and query is implied by 'по тексту'. However, limit is entirely undocumented, and the exact semantics of from_user without chat remain ambiguous.

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 and resource: 'Поиск сообщений по тексту' (search messages by text). It also clarifies the scope difference between global and chat-scoped search, which adds precision. However, it does not explicitly differentiate from the sibling tool 'search_public', so it falls short of a 5.

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

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

The description clearly explains when to search globally (no chat) versus within a specific chat (with chat), which is strong practical usage guidance. It also notes that from_user works together with chat. However, it does not mention when to prefer this tool over alternatives like search_public or get_history, so it lacks explicit exclusions.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses the global scope, the entity types searched, the matching key, and the 3-character minimum. It does not mention pagination, result limits, or auth requirements, but the output schema likely covers return shape.

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

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

A single, front-loaded sentence contains all essential scoping information plus the minimum-length constraint. No filler or redundancy.

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

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

The tool is simple with one required parameter and an output schema available. The description provides the key usage prerequisite (3+ characters) and scope. Minor gaps such as limit behavior and explicit alternative routing prevent a 5.

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 meaning to 'query' by explaining it is a name or @username and must be at least 3 characters. The 'limit' parameter is left entirely without semantic context beyond its default 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 states a specific verb ('search') and resource ('public groups/channels and people in Telegram'), and specifies the lookup key (name/@username). This clearly differentiates it from siblings like search_messages, which operate on message content.

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 makes clear this is for global/public discovery rather than in-chat search or contact lookup, so an agent can infer when to choose it over search_messages/get_contacts. It does not explicitly name alternatives or state when not to use it, but the context is unambiguous.

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

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

There are no annotations, so the description carries the burden of behavioral disclosure. It does add useful behavior beyond the schema: parse_mode values, the as_voice/as_video_note/force_document transformation modes, and ffprobe-based video dimension/duration enrichment. However, it does not mention side effects, permission requirements, file-size/format restrictions, or error behavior.

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

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

The description is one compact sentence with parameter semantics delivered in dash-separated clauses. The main action and file types are front-loaded, and every phrase earns its place without 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?

Given that an output schema exists and the description already covers all optional-mode flags and a subtle video-enrichment behavior, the tool is reasonably complete for an agent to invoke. The remaining gaps, such as chat identifier format, path requirements, and failure modes, are minor compared with the covered aspects.

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_description_coverage at 0%, the description compensates by explaining caption, parse_mode, as_voice, as_video_note, and force_document with concrete effects. The two required parameters, chat and path, are only named in the schema, but their meaning is largely self-evident from the 'local file' context and common API conventions.

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 specific verb and resource: 'send local file (photo/video/document/audio)'. This clearly separates it from sibling tools like send_message (text) and download_media (retrieve files), so an agent can select it by purpose.

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

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

The intended use is implied by the name and the 'local file' wording, and the parameter explanations clarify modes, but the description does not explicitly state when to prefer send_file over send_message or other siblings, nor does it give exclusions or preconditions.

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 of disclosing behavior. It only restates parameter meanings (parse_mode, reply_to, silent); it does not mention side effects of sending, authentication requirements, chat membership prerequisites, failure modes, or the default link-preview behavior. An agent cannot predict what will happen beyond 'a message is sent'.

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 short and front-loads the core purpose, then succinctly clarifies three key parameters. It earns its place, though a bulleted list or one sentence on remaining options would make it slightly easier 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 simple send operation with an output schema present, the description is minimally viable: an agent knows it sends text and understands the three most ambiguous parameters. However, it lacks any mention of link_preview, destination requirements, or behavioral side effects, and the absence of annotations amplifies these 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?

With 0% schema description coverage, the description adds meaningful semantics: parse_mode allowed values (md|html|none), reply_to as a message id, and silent as disabling notification sound. This goes beyond the bare titles/defaults in the schema, though link_preview and the exact chat/text formats are left 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?

The description opens with 'Отправить текстовое сообщение' ('Send a text message'), a specific verb+resource that clearly distinguishes this from sibling tools like send_file, forward_messages, and edit_message. It identifies both the action and the message type without ambiguity.

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

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

The description gives no guidance on when to use this tool versus alternatives; it never names send_file, forward_messages, or edit_message, and there are no exclusions or prerequisites. The only implied context is via the word 'text', which is too weak to count as real 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?

With no annotations, the description carries the behavioral burden. It usefully discloses that emoji=None/empty removes the reaction and big=true triggers a large animation. However, it does not mention mutation side effects, permission requirements, idempotency, or failure behavior, which keeps it from being more 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?

The description is two compact sentences with the primary action first and the edge-case behaviors second. There is no filler, and every clause adds information.

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

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

For a simple four-parameter tool with an output schema, this is largely complete: it states the operation, the removal edge case, and the big-animation option. It stops short of perfect because it does not explicitly cover prerequisites, possible errors, or the identifier parameters beyond their names.

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 adds meaningful semantics for emoji (null/empty removes the reaction) and big (true means large animation). Chat and message_id are left to their schema names only, which are self-explanatory but not explicitly 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 opens with a specific verb and resource: 'Поставить реакцию emoji на сообщение' (set an emoji reaction on a message). It also distinguishes two modes, adding a reaction and removing one, and no sibling tool covers reactions, so there is no ambiguity.

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

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

Usage is implied: use this tool when reacting to or unreacting from a message. However, the description never explicitly says when to use it versus alternatives such as send_message or send_file, and it provides no when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden of disclosing side effects. It only states the operation itself and says nothing about reversibility, permissions, failure conditions, or what happens if the message is not pinned.

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 single sentence is short and front-loaded, which is structurally clean. However, it is under-specified rather than concise, containing no substantive information beyond what the tool name already conveys.

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

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

With no annotations and no parameter guidance, this one-line tautology is insufficient for an agent to select and call the tool correctly. The presence of an output schema covers return values but not usage context, behavioral effects, or parameter semantics.

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 mentions neither 'chat' nor 'message_id'. The schema only provides types and required status, so the agent receives no additional semantic or format guidance for either 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 translates to 'Unpin a message,' which restates the tool name 'unpin_message' almost verbatim. It identifies the verb and resource but adds no detail beyond the name and does not actively differentiate from the sibling tool pin_message.

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

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

The description gives no guidance on when to use this tool versus alternatives such as pin_message or other message tools. There is no mention of prerequisites, exclusions, or context in which unpinning is appropriate.

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