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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the intended mutation, but does not reveal possible side effects, permission requirements, failure modes, or whether the action is reversible. This is a significant transparency gap for a write 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 with no filler words. It is front-loaded with the action and target, making it easy to scan and immediately grasp the tool's purpose.

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

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

For a two-parameter mutation tool with no output schema and no annotations, the description is too sparse to fully guide correct invocation. It omits important context such as permissions, identifier format, and expected outcomes, and relies entirely on the reader's assumptions about group/channel member management.

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 by explaining the parameters. It weakly implies chat_id is the group/channel and user_id is the user, but it adds no detail about valid identifier formats, accepted types, or how the two parameters relate. The schema only provides bare 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 uses a specific verb ('Add') and resource ('a user to a group or channel'), clearly identifying the tool's core action. It distinguishes itself enough from siblings like remove_participant, though it does not explicitly articulate why this tool differs beyond the obvious add/remove contrast.

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 create_group, create_channel, or get_participants. There is no mention of prerequisites, typical call context, or situations where another tool would be more appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It notes that the operation is reversible ('unarchive'), but does not mention side effects, permissions, impact on messages, or what happens to an archived chat. This is minimal 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 a single, front-loaded sentence with no filler, repetition, or unnecessary detail. Every word contributes to the core meaning.

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

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

For a simple two-parameter toggle tool, the description plus schema may be minimally sufficient. However, the lack of annotations, output schema, and parameter explanations leaves gaps around behavior and return values that the description does not fill.

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

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

Schema description coverage is 0%, so the description needed to compensate for undocumented parameters. It only hints at the archive boolean through 'archive or unarchive' and provides no explanation for chat_id, default behavior, or how to indicate unarchiving.

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

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

The description names a specific action (archive/unarchive) and resource (chat), making the tool's purpose immediately understandable. It does not explicitly position itself against siblings, but no other sibling performs archiving, so the action itself differentiates it.

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 when-to-use or when-not-to-use guidance and no mention of alternatives from the sibling list. The intended use is only implied by the verb phrase, leaving the agent to infer when this tool is the right choice.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the action is destructive and requires confirm=true, which is essential safety information. However, it does not describe the actual effects of blocking, whether it can be undone, or any side effects. It is minimal but not misleading.

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 focused sentence with the critical safety condition front-loaded. There is no wasted text. The heavy capitalization and parenthetical style are slightly rough but still efficient.

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

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

For a destructive tool with no annotations and no output schema, the description plus schema give enough to attempt a call: provide user_id and set confirm=true. But it omits what blocking does, when it is appropriate, and how to reverse it. The sibling unblock_user hints at reversibility but is not referenced.

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 only 50%; user_id has no schema description. The tool description does not clarify accepted formats or semantics for user_id, and confirm is already described in the schema, so the description adds no new parameter meaning. Low coverage demands more compensation than this.

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

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

The description states a specific verb and resource: 'Block a user.' It is clearly distinguishable from the sibling tool unblock_user, so an agent knows exactly which action is being invoked without needing to inspect schemas.

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

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

The description implies usage: when you want to block a user. However, it does not explicitly state when to prefer block_user over alternatives or mention unblock_user as the reversing operation. The confirm requirement is a precondition, not 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 provided, the description carries the full burden of behavioral disclosure, but it only reveals that the tool reads cached messages. It does not state whether cache staleness matters, whether an explicit sync is required first, whether results are sorted, or any side effects. This is a thin behavioral contract for a tool with no annotation safety net.

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

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

The description is a single, focused sentence that front-loads the core purpose and result. It wastes no words, though it could benefit from a brief note on caching behavior or output ordering without losing conciseness.

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

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

The tool has no output schema and no annotations, leaving the description as the sole source of contextual information. It does not explain what the return value looks like (e.g., array of senders with counts, sorted descending), the role of the optional parameters beyond their schema defaults, or how cache freshness affects results. For a completly optional-parameter analytics tool, this is insufficient.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description adds minimal semantic value beyond naming the output ('top senders by message count'), which weakly ties to the limit parameter. Baseline 3 applies here.

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 ('Get'), states the resource ('cached messages'), and specifies a concrete output ('top senders by message count'). It is clearly distinguishable from most siblings, though it does not explicitly differentiate itself from get_dialogs_stats, which could also provide chat analytics.

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 through 'from cached messages'—an agent can infer this tool should be used when analytics from cached data are desired. However, there is no explicit mention of alternatives (e.g., get_dialogs_stats) or when not to use this tool, leaving the routing partially to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates the action is local and cache-only, but it does not explain side effects such as whether the cache will be regenerated, whether pending messages are lost, or whether any authentication or permissions are needed. Given the destructive nature of 'wipe', this gap is significant.

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 of six words with no filler. Every word contributes to conveying the tool's purpose.

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

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

For a zero-parameter, no-output-schema tool, the description captures the core operation, but it omits behavioral context like reversibility or impact on other operations. The missing usage guidance and side-effect disclosure make the description partially incomplete for an agent deciding whether and when to invoke it.

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

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

The tool has zero parameters and the schema is fully complete, so the description does not need to explain parameters. Baseline for 0 parameters is 4, and the description correctly adds nothing unnecessary.

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

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

The description uses the specific verb 'Wipe' with the resource 'local message cache', clearly indicating the action and target. It is distinct from sibling tools like delete_message or export_cached_messages, though it does not explicitly name an alternative to disambiguate from.

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 this tool should be used versus alternatives such as sync_messages or export_cached_messages. No context is provided about scenarios where clearing the cache is appropriate or when it should be avoided.

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 disclose behavioral this description does not mention permissions, side effects, idempotency, uniqueness constraints, or what happens after creation. The behavior is underspecified beyond the basic action.

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

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

The description is short and front-loaded, with no wasted words. However, this is under-specification rather than efficient completeness: it is concise but at the expense of the additional context an agent needs.

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

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

For a creation tool with no annotations and no output schema, the description is too thin. It does not clarify what a channel is, what fields matter, what the result of creation looks like, or how this tool fits among siblings like create_group.

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 adds no meaning to the title or about parameters. The required title field is not explained, and about is entirely omitted, so the agent has no additional semantic signal beyond the parameter names.

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 verb and resource—'Create a new channel'—so an agent can tell it apart from unrelated tools like search_messages or delete_chat. However, it does not explain how a channel differs from the closely related create_group sibling, so differentiation is not fully fleshed out.

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 create_channel versus create_group or set_chat_title. There are no prerequisites, exclusions, or alternative tool references, leaving the agent to guess the intended context.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states the obvious action of creating a group and does not disclose side effects, permission requirements, whether members are notified, idempotency, or any constraints.

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 wasted words. However, it essentially restates the tool name and adds no meaningful information, so it is concise but not substantively informative.

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, no output schema, undocumented required parameters, and no mention of how the group is created or what the results are, the description is far too thin for an agent 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 'title' or 'users' at all. The agent receives no semantic help beyond raw parameter names, which is insufficient for correctly constructing the 'users' array with mixed integer/string items.

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 ('Create') and resource ('group'), and the tool name plus sibling 'create_channel' provide basic differentiation between group and channel creation. However, it does not detail what a group is in this context or how it differs behaviorally from a channel.

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

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

No guidance is provided on when to use this tool versus alternatives. The sibling list includes 'create_channel' and many chat-related tools, but the description does not mention any selection criteria, prerequisites, or exclusion conditions.

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

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

With no annotations provided, the description explicitly marks the action as DESTRUCTIVE and states that confirm=true is required, which is important safety context beyond the bare action. It does not go deeper into irreversibility or side effects such as whether messages are permanently removed, which is why 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?

The definition is a single compact sentence with the most critical safety detail front-loaded in a parenthetical. There is no redundant information or filler.

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

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

The two parameters and destructive confirmation requirement are covered, and the operation is simple. However, with no annotations and no output schema, the agent is left without explicit information about what deletion means for the chat, whether it is permanent, or what the unconfirmed warning/return state looks like.

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 description adds little beyond the schema: chat_id is implied by 'Delete a chat,' and confirm's behavior is already documented in the input schema. With only 50% schema description coverage, the description does not fully compensate for chat_id's missing schema description, but both parameters are reasonably self-explanatory from their names 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 'Delete a chat' states a specific verb and resource, making the core operation clear and distinguishing it from siblings like delete_message by the object type. However, the wording closely echoes the tool name and does not explicitly contrast with near-alternatives such as archive_chat or leave_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?

There is no guidance about when to delete a chat versus archiving it, leaving it, or deleting individual messages, despite those alternatives existing in the sibling list. The only usage condition mentioned is the confirm flag, which relates to safety rather than choosing this tool over another.

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. 'DESTRUCTIVE' and 'requires confirm=true' are a valuable warning and guard, but the description omits permanence, permissions, side effects on replies or media, and what happens when confirm is false beyond the schema note.

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 dense sentence fragment with no filler, and the destructive warning is front-loaded. It is appropriately terse for a simple destructive tool, though it leans on the schema for detail.

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

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

For a destructive three-parameter tool with no annotations and no output schema, the description is too thin. It tells the agent that deletion requires confirm=true but not what response to expect, what happens when confirm is false, or any constraints on message_ids, making safe invocation under-specified.

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?

Only the confirm parameter has a schema description, and the tool description does not compensate for the low 33% coverage. chat_id and message_ids are left as bare typed names with no added meaning about their format, relationship, or constraints.

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

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

The description clearly states the verb-object relationship 'Delete messages' and adds the destructive confirmation guard, so an agent understands it removes message resources rather than chats or other entities. It does not explicitly name sibling tools like delete_chat, but the resource scope is unambiguous.

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

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

The parenthetical 'requires confirm=true' gives a direct invocation requirement for a destructive action. However, it does not explain when to prefer this over delete_chat, whether there are prerequisites, or when not to use it, so the usage guidance is only implied.

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

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

No annotations are present, so the description carries the full burden. 'Download media files in bulk' conveys the core action and implies files are saved locally, but it does not disclose behavior like writing to the filesystem, creating the output directory, overwrite behavior, or whether the operation is otherwise non-destructive to the chat. This is minimally adequate but lacks richer behavioral context.

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

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

The description is one concise sentence with no filler. It leads with the action verb and includes the most important qualifying context, 'from a chat in bulk,' while leaving parameter details to the schema. Every part of the 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 plus the fully documented schema is enough to understand the call surface, but with no annotations and no output schema, the description does not mention what the tool returns after download, where files are saved by default, or potential side effects/time costs. This is adequate but has clear gaps for an agent invoking a bulk-download 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 100%, so the baseline is 3. The description adds little beyond the schema: 'photos, documents' echoes the media_type enum and 'bulk' loosely reflects the limit parameter. It does not clarify chat_id formats, output_dir semantics, or limit bounds beyond what the schema already states.

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

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

The description uses the specific verb 'Download' with a clear resource: 'media files (photos, documents) from a chat in bulk.' The 'in bulk' phrasing distinguishes it from the sibling tool 'download_media,' which likely handles individual media downloads. This is a precise, non-tautological statement of what the tool does.

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

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

The description implies usage when bulk media download from a chat is needed, but it does not explicitly state when to use this tool over alternatives such as 'download_media' or 'export_chat.' No exclusions, prerequisites, or alternative routing are provided. The 'in bulk' wording gives weak usage context but no direct 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 explaining behavior. It only states that media is downloaded, but does not disclose output format, file handling, permissions, side effects, or whether this is a read-only operation. This is a meaningful gap for a tool with no structural safety hints.

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. Every word contributes to identifying the action and resource, and it is appropriately compact for a simple tool.

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

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

The tool is low in complexity, and the core operation is clear, but the description is incomplete for agent decision-making: it lacks return-value information, usage context, and any distinction from the closely related download_chat_media sibling. It is minimally viable but has clear gaps.

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

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

Schema description coverage is 0% and the description does not elaborate on chat_id or message_id. The names and the phrase 'from a message' imply their roles, but the description adds no concrete details about formats, constraints, or relationships between the parameters beyond the schema's basic type declarations.

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 ('Download') with a clear resource ('a photo, video, or document from a message'). It conveys the media types and ties the operation to a specific message, which helps distinguish it from sibling tools like download_chat_media, though it does not name that alternative 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?

There is no guidance on when to use this tool versus siblings such as download_chat_media, get_message, or send_file. No conditions, exclusions, or recommended alternatives are provided, leaving the agent to infer selection criteria from the name and brief description.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Edit a sent message' only indicates mutation of an existing message; it does not state whether the edit is limited to bot-owned messages, whether it changes the visible text entirely, what happens to message metadata, or any constraints like time limits or formatting restrictions.

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

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

The description is extremely concise and front-loaded, with no filler or redundancy. However, it borders on under-specification; while the single sentence is appropriately short, it lacks supporting context that could easily be added without bloating.

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

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

For a mutating tool with no annotations and no output schema, the description is too minimal. It omits any behavioral constraints, prerequisites, error conditions, or return value expectations. An agent cannot fully predict the outcome or requirements of calling this tool beyond the obvious edit action.

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 only 25% (only parse_mode is described), and the description does not compensate. It gives no explanation of chat_id, message_id, or text semantics beyond the tool name's implication. An agent must rely on parameter names alone to infer meaning.

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

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

The description states a specific verb ('edit') and resource ('a sent message'), making the core action clear. It does not explicitly differentiate from sibling tools like send_message or delete_message, but the 'sent message' qualifier implies modifying an existing message rather than creating or removing one.

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

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

No guidance is given on when to use this tool versus alternatives such as send_message, forward_message, or delete_message. The description implies only that the message must already be sent, but there is no explicit context, exclusions, or mention of related tools.

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

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

With no annotations provided, the description carries the full burden of disclosure. It reveals that the operation reads from a local cache, but it does not state whether the operation is read-only, whether it triggers a sync, what the returned entity looks like, or any side effects on the cache. This is a significnt gap for a tool that could conceptually modify or clear cache state.

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

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

Single sentence, front-loaded with the verb and resource, and no wasted words. The format options and filter mention are appropriately concise.

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

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

The tool has no output schema and no annotations, so the description must explain what the export actually returns or produces. It only says 'Export messages... as JSON or CSV', without describing the response structure, file delivery, or how 'local cache' data is bounded. This is incomplete for an agent deciding whether to invoke it and how to interpret the result.

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

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

The input schema already describes four of five parameters, so baseline is 3. The description's 'with optional filters' vaguely covers the filter parameters but adds no extra detail about how they behave; it does not, for example, clarify 'limit' semantics or chat_id format. The high schema coverage carries the weight here.

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 ('Export') and resource ('messages from the local cache') and mentions formats and filters, making the core function clear. However, it does not explicitly distinguish itself from the sibling tool 'export_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 phrase 'from the local cache' implies this is for locally stored messages rather than live/full chat data, giving some context. Yet there is no explicit guidance about when to prefer this over export_chat, clear_cache, or get_new_messages, and no mention of 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 full burden of behavioral disclosure. It reveals the output format and a call limit, but does not state whether export modifies state, requires auth, has rate limits, or what happens beyond 1000 messages.

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

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

The description is a single compact sentence with no filler; the primary action, resource, format, and limit are all front-loaded.

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

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

For a simple two-parameter tool, the description covers the core behavior and limit. However, with no output schema and no annotations, it leaves open important operational details such as pagination behavior, response shape, and auth expectations.

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 relates 'chat' to the chat_id concept and the 1000 cap to the limit parameter, but never names chat_id or limit or explains types or formats, leaving room for misinterpretation.

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 a clear verb-resource pair: 'Export messages from a chat', and adds output format JSON and a call limit. It does not explicitly name or distinguish itself from sibling export_cached_messages, so sibling differentiation is only implicit.

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

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

No guidance is given on when to prefer this tool over export_cached_messages, get_message, or message_timeline. The 'max 1000 per call' phrase hints at pagination, but there is no when-to-use or when-not-to-use context.

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

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

No annotations exist, so the description must carry the behavioral disclosure burden. Its only behavioral claim is 'DESTRUCTIVE: requires confirm=true', which merely restates the confirm parameter's schema description and does not explain what actually happens when messages are forwarded, whether original messages are modified or preserved, or what errors might occur. This is insufficient for a tool requiring confirmation for a supposedly destructive 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 brief and the core purpose appears first. The 'DESTRUCTIVE: requires confirm=true' parenthetical is somewhat redundant with the schema, but the overall line is compact and front-loaded, avoiding unnecessary wording.

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

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

With no annotations, no output schema, low parameter coverage, and a forwarded-message operation, an agent needs more context about which chats are supported, what happens to the source messages, and what the response indicates. The description only states the purpose and a confirmation requirement, leaving too many operational details unspecified for reliable 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 only 25%, so the description needs to compensate for undocumented parameters. It vaguely hints at to_chat with 'another chat', but from_chat and message_ids receive no explanation beyond their names. The confirm parameter's semantics are already fully documented in the schema, so the description adds no new parameter insight.

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 ('Forward') and a concrete object ('messages to another chat'), so an agent can tell this is about relaying existing messages rather than composing new ones. It does not explicitly call out the sibling send_message, but the verb 'forward' creates enough distinction. A 5 would require a clearer contrast with 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?

No guidance is given for when to choose this tool over send_message, edit_message, or delete_message. The 'confirm=true' requirement is a condition for execution but not a usage-selection rule. The agent is left to infer applicability 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says 'Get', implying a read operation, but it does not disclose what the returned history looks like, whether admin rights are required, or any limitations such as time range or 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 a single focused sentence with no filler or redundant wording. It front-loads the action and resource effectively while remaining easily parseable.

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 is too thin. It does not explain what fields or items the admin history contains, what errors might occur, or how the limit parameter behaves. For a tool with a simple schema, this is still inadequate for confident 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 indirectly suggests that chat_id refers to a group or channel, but it does not explicitly explain chat_id or limit, and there is no discussion of how limit affects results. The only added semantic is the group/channel scoping.

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 ('Get') and a precise resource ('admin action history for a group or channel'). This clearly differentiates it from sibling tools like get_chat_info, list_chats, and message-related tools, even without naming them.

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

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

There is no explicit guidance about when to use this tool versus alternatives, nor any mention of prerequisites such as admin permissions. The description implies usage for a group or channel, but it provides no exclusions, conditions, or alternative routing.

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 mention whether this is read-only, what kind of data is returned, whether it can accept a username versus numeric ID, or any side effects. The phrase 'Get details' implies a read operation but offers no concrete 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 a single, front-loaded sentence with no wasted words. It is appropriately compact, though it could have used the same brevity to include more meaningful detail about what 'details' means.

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, the description is minimally viable: the agent knows what to target and via the schema knows the parameter format. However, the lack of any information about the output or richer detail semantics leaves meaningful ambiguity about what the tool actually returns.

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

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

The input schema already documents chat_id as 'Chat ID or @username' with full coverage, so the description adds no extra meaning. The mention of 'specific chat' loosely maps to the parameter but does not clarify formats, edge cases, or usage beyond the schema.

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

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

The description states a clear verb and resource: 'details' for a specific chat. It does not explicitly differentiate from sibling tools like list_chats or get_message, but the resource and intent are clear enough for basic selection.

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. There is no mention of exclusions, preconditions, or sibling tools, leaving the agent to infer appropriate usage from the name and description 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only implies a read operation via the word 'Get' and does not mention permissions, returned fields, or possible errors.

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, front-loaded, and contains no filler. It is concise, though it sacrifices informative 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, no output schema, and no behavioral detail, the description leaves the agent guessing what 'details' includes and how this tool relates to sibling tools. It is minimally callable but not fully specified.

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 explain user_id beyond its name and type. It does not compensate for the missing schema documentation.

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

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

The description states a specific verb ('Get') and a specific resource ('contact details'), so it is not a tautology. However, it does not distinguish this tool from closely related siblings such as get_user or list_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?

There is no guidance about when to use this tool versus alternatives like get_user or list_contacts. No context, prerequisites, or use cases are described.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. "Get" conveys a read-only operation and the return content is named, but the description does not disclose scope (all chats versus one chat), output shape, or whether data may be cached or stale.

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 front-loads the key output information. It is appropriately sized for a zero-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?

With no output schema and no annotations, the description is the only source for return value semantics, and it only names them at a high level. It does not define what "chat activity summary" includes or how this tool differs from similar stats/analytics siblings, so 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?

The tool has zero parameters, so the schema already covers everything and the baseline is 4. There is no parameter information needed, and the description's mention of unread counts and activity summary is sufficient context for 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 uses a specific verb ("Get") and names a clear resource ("unread counts and chat activity summary"), so an agent knows this is a read-only aggregation tool. It does not explicitly differentiate it from similar analytics-oriented siblings, but the resource is distinct enough to be understood.

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 this when you need an overview of unread counts and chat activity. It provides no explicit when-not-to-use guidance or alternatives, so an agent must infer when it is preferred over more specific chat or analytics tools.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It does not mention whether generating an invite link creates a new link, requires special permissions, modifies existing invite settings, or has rate limits. The word 'Generate' hints at mutation, but no side effects or responses are described.

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

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

The description is a single focused sentence with no filler. It front-loads the action and object, making it easy to scan quickly.

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

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

For a tool with no output schema, no annotations, and a parameter with no schema description, the description should explain what the tool returns (e.g., a URL), any permission requirements, and whether this creates or retrieves the link. None of that is present, so the agent is left guessing about the invocation result and preconditions.

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 for parameters is 0%, so the description must compensate. 'chat_id' is partially explained by the phrase 'for a group or channel', which signals that the ID refers to the target chat. However, it does not clarify whether the value should be a numeric ID, a username, or a channel handle, and no format guidance is given.

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 ('Generate') and identifies a clear resource ('invite link') with a scoped target ('group or channel'). This is immediately distinguishable from the sibling tools, none of which mention invite links.

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

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

There is no guidance on when to use this tool versus alternatives, such as whether admins only are allowed, whether it applies to supergroups, or what to use when retrieving an existing invite link. The description implies the target is a group or channel, but gives no exclusions or routing advice.

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 verb 'Get' indicates a read-only operation and 'current account info' provides useful scope, which is helpful because there are no annotations to rely on. Still, the description does not disclose whether authentication is required, what fields are returned, or any other behavioral details; with no output schema 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 one short, front-loaded sentence with no filler. Every word adds meaning, and the core action and resource are stated immediately.

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, no-output-schema tool, the description covers the essential context: this returns information about the current account. It could be more explicit about the exact fields or response format, but nothing critical is missing for selecting or 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 input schema has zero parameters, so the baseline is 4. The description reinforces that the operation is about the current account and needs no arguments, which is sufficient for parameter understanding.

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

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

The description states a specific verb ('Get') and a clearly scoped resource ('current account info'), which immediately distinguishes it from sibling tools like get_user or get_status. It is obvious what the tool does and what kind of result to expect.

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 this tool should be used when the current account's information is needed, and that it requires no parameters. However, it does not explicitly contrast it with alternatives such as get_user or get_status, and there is 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 behavioral disclosure. 'Get a single message by ID' conveys only the basic read intent and says nothing about return format, errors, whether it marks the message as read, or any other behavioral trait.

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

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

The description is a single sentence with no filler and addresses the core action immediately. It is concise and front-loaded, though it could include additional useful detail without becoming verbose.

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

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

For a simple direct lookup requiring only chat_id and message_id, the description and schema together are minimally workable for an agent to invoke the tool. However, with no output schema, no annotations, and no mention of return values or edge cases, the description is not fully complete for callers who need to interpret the result.

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 adds 'by ID' without explaining the roles of chat_id and message_id, their types, or how they interact. The parameters are relatively self-explanatory from their names, but the description does not provide the required compensation for the lack of 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 description names a specific verb and resource ('Get a single message by ID') and clearly indicates the tool retrieves one message rather than a list or search result. It distinguishes itself from broad read tools like search_messages and read_messages, though it does not explicitly contrast with siblings such as get_message_replies.

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 for when to use this tool versus alternatives like search_messages, get_message_replies, or read_messages. The description implies a direct lookup by ID, but it does not state when this is preferable or when another sibling should be selected.

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 conveys a read operation ('Get') but does not disclose what the returned structure looks like, whether the parent message is included, how limit affects results, or any pagination/ordering 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 very short and front-loaded with no filler words, which is good for readability. However, it is under-specified to the point of being vague, so the brevity is not fully earned.

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

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

With no output schema, no annotations, and zero parameter descriptions, the tool needs a richer description to be safely callable. The current text leaves key behaviors like response shape, inclusive/exclusive of the parent message, and pagination to inference.

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 adds essentially no parameter meaning. It does not explain chat_id, message_id, or limit beyond what their names imply, so the agent gets no help from either the schema or 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 states a clear verb and resource: 'Get replies/thread for a message.' This distinguishes it adequately from sibling tools like get_message or search_messages, though it does not explicitly name any sibling.

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

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

There is no guidance about when to use this tool versus alternatives such as get_message, read_messages, or get_new_messages. The usage context is only implied by the tool name and short description.

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

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

No annotations are provided, so the description carries the burden. It adds the useful behavioral cue that this is a polling-style, presumably non-destructive read operation. However, it does not disclose whether the call marks messages as read, whether it accesses cache or network, or how it behaves with no new messages—important gaps given sibling tools like read_messages and sync_messages.

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?

One sentence, front-loaded with the core action and filtering condition, plus a concise parenthetical that conveys the intended usage pattern. No wasted words.

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

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

Adequate for a simple polling getter: the description plus schema cover what to pass and why. But with no output schema and no annotations, it leaves return-shape expectations and side-effect behavior unstated, and it does not differentiate from closely related siblings such as read_messages, sync_messages, or message_timeline.

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 67%, with since and chat_id described and limit given a default. The description adds no extra parameter semantics beyond 'timestamp' aligning with since's ISO datetime format, so the schema already handles the parameter burden.

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?

States a specific verb and resource ('get messages'), a precise selection criterion ('newer than a timestamp'), and the intended use pattern ('polling' for real-time awareness). This clearly distinguishes it from siblings like get_message, read_messages, and search_messages.

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

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

The phrase 'polling pattern for real-time awareness' gives concrete usage context: call repeatedly with a since timestamp to stay current. It does not explicitly name alternatives or say when not to use this tool, but the polling cue is sufficient to orient an agent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'List members,' which implies a read operation, but it does not mention pagination/limit behavior, required permissions, what member data is returned, or whether results are complete for large groups or channels.

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

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

The description is a single short sentence with a front-loaded verb-resource-object structure. Every word earns its place 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 tool with no annotations and no output schema, this description is too thin to fully support correct invocation. It makes the overall purpose clear, but omits behavioral details like pagination, return shape, and how limit interacts with fetching all participants, which an agent would likely need.

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 both parameters. 'Group or channel' clarifies that chat_id refers to a chat identifier for groups/channels, but the limit parameter is not explained, and no additional meaning or formatting guidance is provided beyond the schema's 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?

States a clear verb and resource: 'List members of a group or channel.' It identifies the target as a group or channel, helping distinguish from user/contact tools. It does not explicitly differentiate from sibling list/info tools like get_chat_info or list_chats, so it stops 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 phrase 'of a group or channel' gives useful context and implies this is the tool to call when member lists are needed. However, it does not explicitly say when not to use it or compare it with alternatives such as get_chat_info, list_chats, add_participant, or remove_participant.

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 conveys a read-only list operation, but it does not explain whether scheduled messages remain scheduled, whether all statuses are returned, what ordering or pagination applies, or whether special permissions are needed. The description adds little beyond what the name and one-parameter schema already imply.

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

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

The description is a single concise sentence with no redundant words. It is efficiently front-loaded with the action and resource, earning its place without 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?

The tool is low in complexity with one parameter and no nested objects, so a short description is acceptable. However, with no annotations and no output schema, the description omits usage context, behavioral details, and return semantics, leaving noticeable gaps for an agent deciding whether and how to invoke it.

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

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

Schema description coverage is 0%, yet the description provides no meaningful parameter information beyond the existing schema fields. 'in a chat' merely echoes the chat_id parameter's name and does not explain its format, constraints, or how it bounds the scheduled messages returned.

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 'List' with a distinct resource 'scheduled messages' and a clear scope 'in a chat'. This separates it from sibling tools like get_message, search_messages, or send_message without requiring the agent to open their schemas.

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 get_message, read_messages, search_messages, or sync_messages. It does not state exclusions, prerequisites, or a preferred context, leaving the agent to infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get connection status and session health' suggests a read-only operation but does not disclose what specific values are returned, whether it performs any underlying checks, or whether session health information could be stale or require an active session.

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

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

The description is a single, focused sentence that immediately conveys the tool's purpose. There is no redundant wording or filler, making it highly efficient for an agent 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 zero-parameter status check, this description provides a minimal but acceptable level of context. However, with no output schema or annotations, the agent does not know the shape or semantics of the returned status/health data, which leaves some ambiguity about what to expect from 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 has zero parameters, so the schema adds no complexity. The description is not required to explain parameter behavior, and the baseline of 4 applies because there is nothing for parameters 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 description uses a specific verb ('Get') and resource ('connection status and session health'), making the tool's purpose understandable. It does not explicitly contrast with sibling tools, but no sibling appears to target connection status, so the purpose is reasonably distinct.

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 this is the tool to check connectivity and session state, but it provides no explicit guidance on when to prefer it over alternatives or any related context. For a zero-parameter status utility, the implied usage is relatively clear, but no direct usage guidance is given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List' strongly implies a read-only retrieval operation with no side effects, which is helpful, but the description does not clarify what 'available' means, how results are ordered, or what the return structure looks like.

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 phrase with no waste, and the verb is front-loaded. It is appropriately minimal for a parameterless list operation.

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 parameters, no output schema, and no close sibling tools, the main gaps are the response shape and the precise scope of 'available.' Still, an agent can confidently invoke this tool based solely on the description; the missing details are minor for a simple list operation.

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

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

The tool has zero parameters and the schema is effectively complete, so the description has no parameter semantics to explain. The no-parameter baseline of 4 applies here.

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 ('List') and a clear resource ('available sticker packs'), so the tool's operation is immediately obvious. It is also the only sticker-set tool among the siblings, making it easy to distinguish from message, chat, and contact 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 intended use is implicitly clear—call when a user wants to see available sticker packs—but the description gives no explicit when-to-use or when-not-to-use guidance. Since no sibling tool targets sticker sets, the lack of alternative routing is less problematic, but still not explicitly addressed.

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 for behavioral transparency. The verb 'Get' implies a read-only operation, but the description does not disclose authentication requirements, possible errors for invalid user IDs, or whether any side effects exist. It adds little beyond the purpose statement.

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

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

The description is concise and front-loaded with the action, containing no filler words. However, it is so terse that it omits necessary context, so while efficient, it is not maximally helpful as a standalone definition.

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 and no annotations, this description is minimally usable but incomplete. It does not clarify what 'profile info' includes, how user_id should be interpreted, or when to choose this tool over sibling retrieval tools, leaving key selection and behavior gaps.

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

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

Schema description coverage is 0%, and the description does not explain the user_id parameter. The parameter name and type are somewhat self-explanatory, but the description does not clarify whether a string value is a username, phone number, or other identifier, so it fails to compensate for the missing schema documentation.

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

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

The description states a specific verb ('Get') and resource ('user profile info'), clearly indicating the operation is retrieving a user's profile. However, it does not differentiate from sibling tools like get_contact or get_me, which could overlap in 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?

There is no guidance about when to use get_user versus alternatives such as get_contact, get_me, or get_status. The description provides no context on selection criteria, prerequisites, or exclusions.

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

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

With no annotations provided, the description takes on the full disclosure burden and clearly flags the action as DESTRUCTIVE and requiring confirm=true. This gives the agent critical safety information beyond the bare tool name, though it does not describe additional side effects such as whether membership is permanently lost or whether messages remain accessible.

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

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

The description is a single short sentence with the destructive warning front-loaded. It is appropriately minimal and carries no filler, making the key information immediately visible.

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 essential destructive-confirmation behavior. However, without annotations or an output schema, it would benefit from a brief note on what leaving means, whether it is reversible, and which sibling tools to use instead for deleting or archiving a chat.

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 50%, and the description does little to compensate. It mentions 'requires confirm=true', but that merely restates the schema's confirmation requirement; chat_id remains undocumented in both the schema and the description, and no additional format, scope, or usage detail is provided.

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

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

The description clearly states the verb 'Leave' and the resource ('a group or channel'), so an agent can understand the action. It does not explicitly distinguish leave_chat from related destructive sibling tools like delete_chat or remove_participant, but the verb itself is reasonably specific.

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

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

No when-to-use guidance or comparison to alternatives is provided. The description says nothing about when an agent should choose leave_chat over delete_chat, archive_chat, or remove_participant, leaving the selection decision to inference.

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

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

With no annotations, the description carries the behavioral burden. It discloses that unread counts are included and implies a non-mutating read operation, but it does not mention ordering, pagination behavior, whether archived dialogs are included, or any access prerequisites.

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

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

The description is a single compact sentence with no filler or redundant wording. It front-loads the core action, resource, and key output detail (unread counts) 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 one-parameter list tool, the description captures the core purpose and result shape adequately. Still, with no annotations and no output schema, it leaves minor behavioral gaps such as sort order, pagination semantics, and whether the operation has side effects.

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

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

The input schema already documents the single 'limit' parameter with a default and description, so schema coverage is complete. The description adds no additional parameter-specific meaning, which is acceptable but not value-adding.

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 ('List') and a concrete resource ('all dialogs') while enumerating the chat types (groups, channels, DMs). This clearly differentiates it from siblings like get_chat_info or get_dialogs_stats, which target single chats or statistics.

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 'List all dialogs' implies a straightforward enumeration use case and makes clear it is not for fetching a single chat or stats. However, it does not explicitly state when to prefer this tool over get_dialogs_stats or search-based siblings, nor does it call out 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?

With no annotations, the description carries the full burden, but it only states the basic action. It does not disclose return format, ordering, pagination, whether deleted or blocked contacts are included, or any side effects. The read-only nature is implied but never explicit.

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 phrase with no wasted wording. Every word contributes to meaning, and the description is appropriately sized for a tool with no parameters and no complex behavior.

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

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

For a zero-parameter list tool, the description is minimally sufficient, but it lacks any clarification of what 'contacts' means in context, what the returned data looks like, or how it relates to get_contact and get_user. It is adequate but leaves a few practical gaps for an agent.

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

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

The tool has zero parameters, and the schema confirms this with 100% coverage. Since there is nothing to document, the description does not need to add parameter-level detail. Baseline 4 is appropriate for a parameterless tool.

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 ('List') and resource ('contacts'), clearly identifying the action. It distinguishes from get_contact by pluralizing 'all contacts', but it does not explicitly name or route to the sibling alternative for a single contact.

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 about when to use this tool instead of get_contact, get_user, or list_chats. There is no context for selecting this tool over alternatives, so the agent must infer from the name alone.

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

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

With no annotations, the description carries the burden of explaining behavior. It discloses the per-topic return fields and the important invariant that the General topic is always id 1, which is useful behavioral context beyond the schema.

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

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

Three short sentences, each carrying distinct value: scope, output, and an invariant. The essential information is front-loaded and there is no fluff.

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

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

For a simple listing tool with three parameters and no output schema, the description adequately explains what the tool returns and notes the general topic invariant. It does not mention ordering or pagination behavior, but the schema already specifies the limit cap and the tool's purpose is clear.

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

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

Schema description coverage is 67%, so most parameter meaning is already provided by the schema. The description adds the example 'GLC' for chat_id and notes that the General topic is id 1, but does not add substantial detail about limit or query beyond what the schema already states.

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

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

The description states a specific verb and resource: 'List topics in a forum supergroup', with a concrete example ('GLC'). It also enumerates the return fields, making the tool's function unmistakable and distinct from sibling tools like list_chats.

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

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

It clearly indicates this tool is for forum supergroup topics, which implies when it should be used versus list_chats or chat_info tools. It does not explicitly state exclusions, but the context is strong enough for an agent to select it appropriately.

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

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

With no annotations, the description carries the full burden, and it does disclose the per-topic unread cursor side effect and the fact that topic_id is needed for forum supergroups. However, it does not mention permissions, idempotency, or whether the operation only affects the current user's read state.

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

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

Two sentences with no filler: the main action is front-loaded, and the conditional forum behavior is placed after it. 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 simple two-parameter mutation, the description covers the core action and the one special-case parameter, but no annotations or output schema exist and there is no mention of the return value or how this relates to read_messages. It is minimally adequate but leaves selection and result expectations unstated.

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 only 50% since chat_id lacks a description; the description does not add meaning to chat_id. It does reinforce topic_id's purpose ('1 for the General topic', 'per-topic unread cursor'), but much of that duplicates the schema's topic_id 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 opens with a specific action and resource ('Mark a chat as read') and adds a clear special-case behavior for forum supergroups. It does not explicitly contrast itself with the sibling read_messages, but the chat-level wording helps distinguish it from message-level operations.

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

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

No explicit when-to-use guidance or alternative tool is mentioned; the only conditional is about topic_id, which is parameter-level guidance. Given the presence of the sibling read_messages, an agent receives no help choosing between the two.

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 usefully discloses that the data comes from the local cache and that this is a read-only counting operation. However, it does not mention cache staleness, whether the cache is required, or any implications of missing/partial cached data.

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 wasted words. It conveys the core operation, resource, grouping, and data source 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 counting tool, the description captures the main behavior, but there is no output schema and no annotation context. It could clarify the return shape, ordering, or treatment of empty periods, and it does not address possible ambiguity with analytics-related siblings.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds no meaning beyond the parameters, aside from reinforcing the hour/day grouping. This matches the baseline of 3 for fully documented schemas.

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 ('Get'), a precise resource ('message counts'), and the grouping dimension ('by time period (hour or day)'). It also names the source ('local cache'), which distinguishes it from remote search or analytics 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?

The phrase 'from the local cache' implies this is for cached message data, and the counting/grouping behavior implies a timeline analysis use case. However, it does not explicitly state when to prefer this over siblings like chat_analytics or today_messages, nor does it give exclusions or alternatives.

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

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

With no annotations, the description carries the full disclosure burden. It signals a mutation by saying 'mute or unmute', but it does not disclose permissions, reversibility beyond the implied toggle, response behavior, or side effects. This is a minimal behavior statement rather than a transparent account of the tool's 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 one short, front-loaded sentence with no filler. It is efficient and easy to parse, though its brevity leaves other dimensions under-specified.

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 boolean action with no annotations and no output schema, the description conveys the core operation and relies on the schema for the rest. It is minimally viable, but an agent still lacks guidance on exact mute-flag usage, return values, and preconditions.

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 must compensate for explaining chat_id and mute. It only says 'for a chat' and implies a toggle; it never explicitly states that mute=true silences notifications and mute=false restores them. The description adds only a thin layer over the raw schema.

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

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

The description states a specific operation—mute or unmute notifications—and identifies the resource as a chat. It is immediately distinguishable from sibling chat-management tools like archive_chat, leave_chat, or set_chat_title, none of which deal with notification muting.

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 prefer mute_chat over alternatives or what preconditions apply, such as whether the user must be a chat participant. The large sibling list contains many chat actions, but no criteria are provided for selecting this one.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action itself and gives no information about side effects, permissions, whether pinning replaces an existing pinned message, or failure modes. This falls well short of a transparent behavioral description.

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

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

The description is very short and front-loaded, with no filler. However, given the absence of annotations and parameter documentation, the brevity reads as under-specification rather than appropriately concise guidance.

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

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

With no output schema, no annotations, and a one-sentence description, the tool lacks contextual completeness. An agent is not told about return values, error conditions, behavioral implications, or how this tool relates to sibling tools like unpin_message.

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 explicitly explain chat_id or message_id. It loosely maps 'a chat' to chat_id and 'a message' to message_id, but provides no additional meaning, constraints, or validation context beyond the bare 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 'Pin a message in a chat' uses a specific verb and resource (message in a chat), making the core function clear. It does not explicitly differentiate from sibling tools like unpin_message, but the action itself is unambiguous enough for an agent to understand what the tool does.

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, no prerequisites, and no mention of the inverse operation (unpin_message). The only usage signal is implicit in the phrase 'Pin a message in a chat', leaving an agent to infer context.

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

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

Annotations are absent, so the description carries the full behavioral burden. It discloses 'recent' and topic scoping but says nothing about ordering, defaults, pagination, side effects, or response shape. It does not contradict anything, but it is thin.

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, each earning its place: purpose first, topic-specific usage second. 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?

For a 5-parameter read tool with no annotations and no output schema, the description leaves key operational details implicit, such as limit semantics, from_user filtering, offset_date ordering, and default behavior. It supports the simplest call but not reliable advanced use.

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 only 40%, with limit and from_user left undocumented and offset_date only minimally described. The description adds forum topic context that the schema already provides, and it does not explain the meaning of the remaining parameters.

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

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

States a specific verb and resource ('Get recent messages from a chat'), so the core function is unambiguous. It does not differentiate from siblings like get_new_messages or message_timeline, but the basic purpose is 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?

No guidance on when to select this tool over the many reading-related siblings such as get_new_messages, message_timeline, or search_messages. The only usage context is the forum topic_id caveat, which is parameter-level 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It does flag the action as DESTRUCTIVE and states the confirm=true requirement, which is valuable. However, it does not disclose side effects, reversibility, permission requirements, or what happens to the removed user's access beyond the immediate removal.

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

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

The description is a single clear sentence with no filler. It front-loads the action and immediately surfaces the critical destructive confirm requirement, making it easy for an agent to parse quickly.

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

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

For a destructive action with no annotations and no output schema, this description is too thin. It does not explain what success or failure looks like, does not clarify chat_id/user_id formats, and does not mention permissions or consequences beyond the basic removal. The confirm requirement is helpful, but more context is needed for a destructive 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 only 33%, and the description does not compensate for chat_id and user_id being undocumented in both the schema and the description. The confirm parameter is well explained in the schema, but the two core identifiers remain ambiguous in semantics, especially since both accept integer or 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 states a specific action ('Remove a user') and target resource ('group or channel'), making the tool's function immediately clear. It is easy to distinguish from sibling tools like leave_chat, delete_chat, and block_user because it uniquely targets removing another user from a 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 a participant must be removed from a group or channel. It also communicates a critical usage requirement ('requires confirm=true'). However, it does not explicitly mention alternatives or when not to use it, such as preferring block_user for global blocking or leave_chat for removing oneself.

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 only states the deferred-send behavior. It does not disclose cancellation options, side effects, validation of schedule_date, timezone handling, or what a successful schedule operation returns.

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

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

A single sentence with no filler, front-loading the core action and scheduling qualifier. It is appropriately compact for such a high-level purpose statement.

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

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

For a mutation tool with no annotations, no output schema, and four parameters, the description is too sparse. It omits crucial scheduling semantics such as past-date handling, reply_to behavior, and post-call expectations, so an agent cannot confidently invoke it.

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

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

Schema coverage is only 25%; only schedule_date has a description ('ISO datetime'). The tool description adds no parameter-level meaning, and reply_to is entirely unexplained for the agent.

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?

States a specific action ('Send a message') with a clear qualifier ('at a future time'), which distinguishes it from sibling send_message. The resource and scheduling intent are immediately 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?

No guidance on when to use schedule_message versus alternatives like send_message or get_scheduled_messages. The description implies future delivery but never explicitly routes the agent between immediate and scheduled sending.

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 explaining behavior. It conveys a read-only keyword search with optional chat/chat-type scoping, but omits details about return format, limit behavior, or cache vs live search 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?

A single front-loaded sentence with zero wasted words. It clearly separates the core action from the optional modifiers.

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

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

For a tool with 4 parameters, no output schema, and no annotations, the description omits return shape, pagination/limit semantics, and relationship to sibling search tools. It is not enough to confidently use the tool in a broader search workflow.

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 only 25%. The description clarifies query as keyword and chat_id/chat_type as optional filters, but limit is left undocumented and chat_type already has a schema 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?

States a specific action—'Search messages' by keyword—and optional chat/chat-type scope. This distinguishes it from get_message (by ID) but does not explicitly differentiate it from search_regex.

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

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

No when-to-use or alternative guidance is provided. It does not mention search_regex for regular expressions or get_message for retrieving a single message, so the agent must infer when to prefer this tool.

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

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

With no annotations, the description carries the full burden and does disclose one meaningful behavior: the operation runs locally against the cache and does not call the Telegram API, implying results are bounded by cache freshness and that network calls are avoided. But it does not disclose the return format, whether only message text is matched, result ordering, or that the cache may need syncing first — gaps that matter without annotation backstop.

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?

One sentence, roughly a dozen words, with the verb and resource front-loaded and the decisive local-vs-API distinction in a parenthetical. There is zero filler; 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?

The description covers the what and where (regex search over local cache), and the sibling set (sync_messages, export_cached_messages, clear_cache) makes the cache concept inferable. However, there is no output schema and no disclosure of what results look like, how fresh the data is, or whether the cache must be populated first, so an agent is left guessing at the tool's contract beyond 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 80%, so the baseline is 3 even with no parameter info in the description. The description adds nothing about pattern syntax, limit behavior, or datetime handling beyond what the schema already provides, so it stays at the baseline.

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

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

The description names a specific verb ('Search'), a specific resource ('cached messages'), and a precise mechanism ('regex pattern'). The parenthetical ('runs locally, not against Telegram API') sharply distinguishes it from API-backed siblings like search_messages and read_messages, so an agent can tell them apart without opening schemas.

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 but not explicit: the regex mechanism suggests pattern-based queries and the 'runs locally' clause signals this does not hit the live Telegram API, hinting the agent should prefer API-backed tools when fresh data is needed. However, it never names an alternative (e.g., search_messages) or states a when-not-to-use condition, leaving the routing decision to inference.

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

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

No annotations are present, so the description must disclose behavioral traits. It explains topic/reply behavior but omits side effects such as upload mechanics, file size limits, permission requirements, or return values. 'Send' implies mutation without detailing consequences.

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

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

Two sentences with no filler: the first gives the purpose, the second adds two important parameter behaviors. The structure is front-loaded and 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 tool with 5 parameters, no annotations, and no output schema, the description leaves basic parameter semantics and behavioral side effects implicit. It handles the tricky forum/reply case well but is incomplete overall.

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 only 40%, and the description adds meaning by linking reply_to to topic_id ('within that topic'). It largely paraphrases the schema's topic_id/reply_to descriptions and does not explain chat_id, file_path, or caption semantics, so compensation is partial.

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?

States a specific action ('Send') and resource ('file or photo') with a clear target ('to a chat'), which distinguishes it from siblings like send_voice or send_location. It does not explicitly contrast with send_message, but the resource type makes the purpose 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?

Provides concrete usage guidance for special cases: passing topic_id in forum supergroups and combining reply_to with topic targeting. However, it does not say when to prefer send_file over alternative send tools or when not to use it.

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 behavior disclosure, but it reveals only that a location is sent. It does not mention side effects, permissions, whether anything is irreversibly created, or what response the caller can expect.

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

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

The text is short and front-loaded, which is good, but it is under-specified rather than concise: a single phrase that restates the tool name. It does not earn its place because it adds no useful substance.

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?

Even for a three-parameter send operation, the description is too thin: it fails to state whether location is sent to a chat, how coordinates are ordered, or what happens on success. The schema gives parameter names, but the description supplies the missing operational context.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the three parameters. It does not, offering no information about chat_id, lat, lon, coordinate order, units, or how the location is interpreted.

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 'Send a location' is effectively a rewording of the tool name 'send_location' and adds no new information beyond it. It is not misleading, but it restates the name/title rather than explaining the resource or scope.

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

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

No guidance is provided about when to use this tool versus siblings such as send_message, send_file, or send_voice. The description gives no context, prerequisites, or exclusions, so an agent cannot decide when this is the right tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals the forum-topic targeting constraint but does not state that this is a mutating operation, what happens if topic_id is omitted in a forum supergroup, what permissions are required, whether the call can fail, or what the response contains. For an unannotated 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?

Three sentences, each with a distinct job: the core action, the forum-topic edge case, and the reply combination. The main purpose is front-loaded and no sentence is wasted.

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 handles the two Telegram-specific gotchas — forum topics and reply threading — that would most likely cause an agent to mis-call this tool. But it omits the meaning of chat_id's string form and the default behavior when topic_id is omitted, and with no output schema or annotations the operation's effects and return value are left to inference.

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 60%, and the description adds genuine value by documenting the '1 for General' convention for topic_id and the reply_within_topic combination with reply_to. But the two required parameters, text and chat_id, have no descriptions anywhere, and chat_id's integer|string union is left ambiguous (numeric ID vs @username). The description partially compensates for coverage gaps but not completely.

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?

"Send a message to a chat" states a specific verb and resource that clearly distinguishes this from siblings like edit_message, delete_message, forward_message, and schedule_message. The forum-topic and reply_to detail further pins down the scope. However, it never explicitly contrasts with send_file/send_voice/send_location, leaving that boundary implicit rather than stated, so it stops 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 gives concrete, non-obvious usage direction: pass topic_id in forum supergroups and use 1 for General, and combine reply_to to reply within a topic. But there is no explicit when-to-use vs alternatives guidance — nothing says to prefer forward_message for copying existing messages or schedule_message for delayed sends. Usage context is implied rather than spelled out.

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

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

With no annotations, the description carries the full burden and it does state the core mutation: a reaction is added to a message. It does not disclose side effects such as whether an existing reaction is replaced, whether the reaction is visible publicly, or what error behavior occurs, leaving some behavioral ambiguity.

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

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

A single, front-loaded sentence with no filler. Every word contributes to the core meaning, and the length is appropriate for a tool with three straightforward parameters.

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

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

The definition is minimally viable for a simple react-to-message tool because the action and required parameters are clear from the description plus schema. However, the 0% schema description coverage, lack of sibling differentiation, and absence of any success/error or return-value note leave the agent to make assumptions about 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 should compensate, but it does not explain any parameter semantics beyond the inferable roles of chat_id, message_id, and emoji. It gives no guidance on emoji format (Unicode vs. shortcode), how chat_id should be represented, or what makes a valid message_id.

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

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

The description uses a specific verb ('React'), a clear resource ('a message'), and the payload type ('an emoji'). This makes it immediately distinct from sibling tools like send_message and forward_message, which send new content rather than attach a reaction.

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 when-to-use guidance, no exclusions, and no mention of alternatives. However, the wording 'React to a message with an emoji' implies the appropriate use case when an agent needs to attach an emoji reaction rather than send or edit a 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Send a voice message' discloses none of the important behavioral traits: no indication of whether this mutates state, what prerequisites exist (e.g., valid file path, supported audio formats), whether the action is reversible, or what the response looks like.

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 could be considered front-loaded, but this is under-specification rather than effective conciseness. It contains no useful operational detail beyond restating the tool's name and basic intent.

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

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

The tool has no annotations, no output schema, and sparse parameter documentation, yet the description provides no additional context. It fails to distinguish this from the many sibling file/message tools and omits any mention of prerequisites, return behavior, or error handling, leaving the agent with insufficient information to invoke it reliably.

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 adds no meaning beyond the raw schema. It does not explain that chat_id is the target conversation, what file_path should reference, or what formats/locations are acceptable. With two required parameters and zero enrichment, the agent must guess at their 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 states a specific verb and resource: 'Send a voice message.' This makes the tool's basic function identifiable, and the name aligns well with the described action. However, it does not differentiate this tool from siblings like send_file or send_message, so the scope is clear but not fully disambiguated.

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 explicit guidance on when to use this tool versus alternatives such as send_file, send_message, or schedule_message. The intended use case is only implied by the tool name and brief description, with no conditions, exclusions, or comparisons to sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It conveys that the operation is a mutation ('Change'), but it does not mention side effects, permission requirements, idempotency, or what happens to the previous description. This is minimal context.

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

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

The description is a single, direct sentence with no filler words, front-loading the core action. It is efficient, though additional sentences could have enriched it without significant verbosity.

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 two required parameters, no annotations, no output schema, and zero schema description coverage, the description is far too sparse. It lacks usage context, parameter semantics, behavioral impacts, and any mention of permissions or related alternatives. An agent would need substantial external inference to invoke this confidently.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. The phrase 'a chat's description' loosely implies the 'description' parameter holds the new text, but 'chat_id' is not explicitly linked to the target chat, and no formats, constraints, or error conditions are given.

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 ('Change') and a clear resource ('a chat's description'), making the tool's primary function immediately obvious. It also differentiates from sibling tools like set_chat_title and set_chat_photo, which target different chat attributes.

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 instead of other chat-related siblings, nor any prerequisites such as required permissions. The description simply states the action without contextual cues about appropriate situations.

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 behavioral burden. It only states 'Change a chat's photo' without mentioning side effects, required permissions, whether the previous photo is replaced, or whether the change is reversible. This is a mutation tool, and the description leaves those behaviors undisclosed.

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 earns its place by stating the core operation directly and 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 tool, the description is minimal but still incomplete. There is no information about expected file path semantics, required permissions, return behavior, or failure conditions, and no annotations or output schema help 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 description coverage is 0%, so the description needs to compensate, but it does not explain either parameter. While 'chat_id' and 'file_path' are inferable from the tool name and schema, important details like what file formats are accepted or what 'file_path' refers to are missing.

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 ('Change') and a specific resource ('a chat's photo'), making the tool's function immediately clear. It also distinguishes itself from sibling tools like set_chat_title and set_chat_description, since the resource (photo) is unique.

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 this tool should be used versus alternatives such as send_file or set_chat_title. No context about prerequisites, exclusions, or situations where a different tool would be more appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'change a chat's title' and does not mention permissions, idempotency, side effects, restrictions on the title, or what happens to existing titles.

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

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

The description is a single short sentence with no wasted words, making it easy to parse and front-loaded with the core action. However, it is slightly too terse to fully compensate for the lack of additional behavioral and usage 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?

Given that there is no output schema and no annotations, the description is too minimal. An agent is left to infer whether this modifies an existing chat, what the return value is, whether special permissions are required, and how it relates to similar chat-edit tools.

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

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

Schema description coverage is 0%, so the description fails to clarify either parameter. While 'title' and 'chat_id' are reasonably self-explanatory from their names, the description adds no meaning about chat_id being the target chat or title being the new 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 a specific action and resource: changing a chat's title. The word 'title' distinguishes it from sibling tools like set_chat_description and set_chat_photo, 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?

There is no guidance on when to use this tool versus related tools such as set_chat_description or set_chat_photo. The description simply states what it does without providing context such as 'use this to rename a chat' 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?

No annotations are provided, so the description carries the full burden. It discloses the local SQLite cache side effect and intended purpose, which is helpful, but it does not mention whether sync is incremental, overwrites existing cache data, or what completion/return behavior looks like.

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 states the action, scope, destination, and purpose. There is no filler or redundant information.

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

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

With all parameters documented in the schema and the tool's side effect clearly summarized, an agent has enough to select and invoke it. The main gap is lack of detail about return values, sync semantics, and failure behavior, but those are not critical for invocation.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description adds little beyond reinforcing the all-chats vs. specific-chat distinction already captured by the chat_id parameter 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 uses a specific verb ('Sync') and resource ('messages ... into the local SQLite cache'), clearly distinguishing it from retrieval/search tools like get_message or search_messages. It also clarifies the scope: all chats or a specific 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 communicates when to use the tool: to populate the local cache for offline search and analytics. It also explains the optional chat_id behavior, but it does not explicitly name alternatives or state when not to use it.

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 reveal meaningful behavior: it reads from the local cache and is scoped to today UTC. However, it omits details like message ordering, whether the limit caps the result set, cache staleness behavior, and 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?

A single, front-loaded sentence with no filler. Every phrase ('today UTC', 'local cache') adds distinct semantic value.

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

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

The description is adequate for basic invocation given the simple optional parameters, but with no output schema and no annotations it leaves gaps around return shape, ordering, pagination, and how this relates to sync_messages or get_new_messages. More context would help an agent choose and call it confidently.

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

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

Schema description coverage is 100%, so the parameters are already documented. The description adds little beyond 'all messages', which slightly conflicts with the limit parameter's behavior, but it does not need to compensate for missing schema info.

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 ('Get'), a precise resource ('all messages from today (UTC)'), and a clear source ('local cache'). This distinguishes it from siblings like search_messages, read_messages, and get_new_messages without needing to open schemas.

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

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

The description implies usage for cached messages from today but provides no explicit guidance on when to choose this tool over similar siblings such as get_new_messages, read_messages, or search_messages. No exclusions or alternative 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the action and does not explain side effects, idempotency, permission requirements, or behavior when the user is not already blocked.

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 appropriately short and front-loaded, conveying the essential action in four words with no filler. It is concise rather than under-specified for such a simple tool.

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

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

For a one-parameter tool with no output schema and no annotations, the description is minimally adequate but has clear gaps. It does not address edge cases like unblocking an already-unblocked user or what the expected result is, though the basic action is unambiguous.

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 the required user_id parameter at all. While the parameter is self-explanatory from its name, the description adds no meaning beyond the schema and fails to compensate for the coverage 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?

The description uses a specific verb 'unblock' with a clear resource 'user', so an agent immediately understands the core action. It does not explicitly contrast with the sibling block_user, but the inverse relationship is strongly implied by the verb itself.

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 unblock_user versus block_user or any other user-related tool. There is no mention of prerequisites such as the user needing to be currently blocked.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but 'Unpin a message in a chat' only states the action without covering permissions, reversibility, idempotency, or error behavior on a non-pinned message. This is minimal and leaves important behavioral traits unspecified.

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 redundancy. It is appropriately sized for a simple, single-purpose operation and every word contributes to understanding.

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 simplicity of the operation and self-explanatory parameters, the description is minimally adequate for an agent to make the call. However, with no annotations, no output schema, and no usage guidance, it stops short of being fully complete for decision-making.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain chat_id or message_id beyond the obvious context. While the parameter names are self-explanatory, the description adds no additional meaning about expected formats or relationships.

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

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

The description clearly states the verb 'Unpin' and the resource 'a message in a chat', so an agent can tell it performs the inverse of pin_message. It does not explicitly distinguish itself from siblings, but the action is unambiguous and specific enough for basic selection.

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 like pin_message or delete_message. It also does not mention any conditions, prerequisites, or when not to use it, so the agent gets no routing hints beyond the obvious intent.

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