mcp-telegram

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

The description adds no behavioral context beyond the annotations (openWorldHint, idempotentHint). It does not disclose side effects such as contact approval flows, duplicate handling, or the purpose of addPhonePrivacyException, leaving the agent with minimal behavioral understanding.

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, making it extremely concise and front-loaded with the core action. It contains no wasted words, though its brevity also contributes to under-specification.

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 six parameters, no output schema, and minimal annotations, the description is far too terse to be complete. It fails to explain parameter purposes, return behavior, or special conditions such as phone being required for contact lookup, leaving significant gaps for the agent.

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

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

The schema covers only 17% of parameters with descriptions (only 'phone'), and the tool description mentions no parameters. The implied meaning of 'user' is insufficient to explain required fields like firstName/lastName, accountId, and addPhonePrivacyException, making the description unhelpful 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 uses a specific verb 'Add' and clearly identifies the resource as 'a user to your contacts', distinguishing it from sibling tools like list_contacts, delete_contact, and search_contacts. It is unambiguous and directly states the tool's function.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites like authentication, how to obtain the 'user' parameter, or when to prefer search_contacts or block_user over adding a contact.

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

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

The description adds some behavioral context beyond the annotations by explaining that the tool pins a sticker and that `unsave: true` removes it. However, it does not disclose potential side effects, permissions, or the result of pinning the same sticker again. The idempotentHint and openWorldHint are already present, but the description could do more to elaborate on the tool's runtime 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 extremely concise: two short sentences, front-loaded with the primary action and a secondary note on the unsave flag. Every word contributes meaningful information, with no wasted text 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 4 parameters, no output schema, and minimal annotations, the description covers the core action and the unsave variant but omits important context like prerequisites (e.g., must have a sticker document ID), error conditions, and the effect of repeated calls. It is adequate for a simple utility but leaves gaps that could affect proper usage.

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

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

Schema description coverage is 0%, so the burden falls on the description. It explains only the `unsave` parameter, leaving `documentId`, `accessHash`, and `accountId` without any additional meaning. While parameter names may be self-explanatory to experienced users, the description fails to clarify their purpose or required format, making it insufficient for reliable invocation.

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

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

The description clearly states a specific action: 'Pin a sticker to the recently used list.' This uses a distinct verb ('pin') and resource ('recently used list'), and is not a tautology. It also distinguishes from any sibling tools, as none deal specifically with recent stickers.

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

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

The description provides no guidance on when to use this tool versus alternatives. The only contextual note is 'Use `unsave: true` to remove it,' which explains a parameter's effect rather than usage context. There are no exclusions or alternative tool mentions, leaving the agent without clear decision-making criteria.

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

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

With only openWorldHint annotation, the description fails to disclose critical behavioral traits such as whether boosts are consumed permanently, whether the action is reversible, or any permission requirements. It simply restates the action without adding operational 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, efficient sentence that front-loads the verb and object. There is no filler or redundant information, making it maximally concise for the content it provides.

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

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

This is a mutating tool with no output schema and minimal annotations. The description leaves essential unknowns unresolved—such as the effect of applying boosts, reversibility, and how account selection works—making it inadequate for safe and correct 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?

The input schema has 0% description coverage, and the description does not explain the meaning of `peer`, how `slots` are identified, or the purpose of `accountId`. The only hint, 'one or more,' merely restates the schema's minItems constraint.

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 ('apply') and clearly names the resource ('boost slots' to 'a channel'). It distinguishes the action from sibling tools like get_my_boosts, and adds 'one or more' to indicate quantity, avoiding a mere tautology.

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 mention of prerequisites (e.g., owning boost slots or channel permissions), and no reference to sibling tools like get_my_boosts for checking available slots.

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 already declare destructiveHint, so the agent knows it is destructive. The description adds useful context about untilDate time-limiting and the default being forever, but it does not disclose permission requirements, reversibility, or impact on existing 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 two concise sentences, front-loaded with the core action and no 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?

With 4 parameters, no output schema, and only one parameter explained, the description is incomplete. It lacks context on how to specify the user (e.g., username vs ID), required admin permissions, and what happens to the user's messages or membership.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It only explains untilDate (unix seconds, default forever), while peer, user, and accountId are left undefined, leaving the agent to guess their meaning or format.

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 'Fully ban a user' with a specific verb and resource, and the title clarifies 'from a channel/supergroup'. This distinguishes it from sibling tools like restrict_user, kick_participant, and block_user, making 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?

No guidance is provided on when to use this tool versus alternatives such as restrict_user, kick_participant, or block_user. The description only states what it does, not in which situations it should be chosen.

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

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

The description restates the title and adds no behavioral context beyond 'from contacting you'. While annotations include idempotentHint and openWorldHint, the description fails to disclose consequences like effects on existing conversations, reversibility, or whether the user is notified.

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, front-loading the core action. It is appropriately economical, though it sacrifices detail for brevity.

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 two-parameter schema and lack of output schema, the description is too sparse to provide adequate context for correct invocation. It leaves the optional 'accountId' parameter unexplained and does not clarify what 'blocking' entails in practice.

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

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

With schema_description_coverage at 0%, the description must explain the parameters. It does not mention 'user' or 'accountId' at all, leaving their formats, purpose, and necessity completely undocumented.

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

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

The description 'Block a user from contacting you' uses the specific verb 'block' with a clear resource ('a user') and a scope ('from contacting you'). This clearly distinguishes the tool from siblings like 'mute_peer' (which silences notifications) and 'ban_user' (which typically operates in a group/channel context).

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'unblock_user', 'mute_peer', or 'ban_user'. It simply states the action without any context about suitable scenarios 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?

Annotations already declare readOnlyHint=true, so the read-only behavior is known. The description adds the channel/supergroup scoping but does not describe behavior for unavailable usernames or potential edge cases. With annotations present, this is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no wasted words. It conveys the essential action and target resource effectively.

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

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

Despite the tool's simplicity and read-only annotations, the complete lack of parameter documentation and usage guidance makes it incomplete for an agent. The 'peer' parameter is particularly ambiguous, and no return behavior is 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 coverage is 0% and no parameter descriptions are provided. The description clarifies that 'username' refers to a channel/supergroup username, but 'peer' and 'accountId' remain unexplained, leaving the agent uncertain about required inputs.

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

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

The description clearly states the tool's function: it verifies whether a desired channel/supergroup username is free. This distinguishes it from siblings like update_username (which modifies) and resolve_username (which resolves existing usernames), making the purpose unambiguous.

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

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

The usage context is implied (pre-checking username availability before claiming one), but there is no explicit guidance on when to use this tool versus alternatives like resolve_username or update_username. No exclusions or alternative recommendations are provided.

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

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

With annotations of openWorldHint and idempotentHint, the description adds the key behavioral fact that this acts as save_draft with empty text, effectively clearing the draft. It does not contradict the annotations and provides useful context beyond them, though it omits details like return values or side effects.

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

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

The description is a single sentence, front-loaded with the key action, and contains no filler. It is appropriately sized for the tool's simplicity.

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

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

While the tool is simple, the complete absence of parameter semantics and no output schema leaves the description insufficient for confident invocation. The agent may infer the purpose but cannot determine correct input formats without additional context.

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

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

The description provides zero information about the 'peer' or 'accountId' parameters. Schema descriptions are also absent (0% coverage), so the agent must guess the meaning of parameters, which is a significant 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 states the tool clears a draft by equating it to 'save_draft' with an empty text. This is a specific verb+resource (clear + draft) and distinguishes it from the related 'save_draft' tool by indicating the special case of empty content.

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

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

The description implies the use case: when you want to clear a draft. However, it does not explicitly contrast with 'save_draft' or other alternatives, nor does it say when not to use this tool. The equivalence gives some guidance but leaves the selection logic implicit.

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

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

The annotations provide openWorldHint and idempotentHint, but the description adds the key behavioral effect ('no further votes are accepted'). It does not disclose whether existing votes are preserved, whether the action is reversible, or any permission requirements. Given the annotations, the description offers minimal additional transparency beyond the core effect.

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

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

The description is a single, front-loaded sentence that immediately states the action and outcome. No unnecessary words or repetition.

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

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

For a tool with three parameters and no output schema or parameter descriptions, this one-sentence description is inadequate. It omits guidance on how to identify the poll (peer/messageId), what the response looks like, and any additional side effects. The annotations provide minimal support, leaving significant gaps in 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% and the description provides no parameter explanations. The agent must infer that 'peer' identifies the chat and 'messageId' identifies the poll, but this is not stated. The description fails to compensate for the total lack of parameter 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 uses a specific verb 'finalize' and identifies the resource 'poll', clearly distinguishing from sibling tools like send_poll, vote_poll, and get_poll_results. It conveys the exact action and outcome succinctly.

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

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

The description clearly implies when to use it: when an active poll exists and you want to stop voting. However, it does not explicitly state when not to use it or mention alternatives like vote_poll or get_poll_results, so it lacks explicit exclusionary 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?

The only annotation is openWorldHint, and the description adds no behavioral context beyond the fact that it creates something. It does not disclose permission requirements, serialization effects, account selection implications, or what happens after creation (e.g., returns chat info).

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 action and uses inline code for the key flags. Every word earns its place, making it concise without unnecessary 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?

With 6 parameters, no output schema, and no behavioral details, the description is insufficient for an agent to fully understand the tool's side effects, return format, or account selection. The description's focus on only two flags leaves significant gaps in 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 only 17%, with only forum having a description. The description clarifies broadcast and megagroup flags and their role in determining channel type, but it leaves accountId, about, and title semantics unexplained, failing to compensate for the low schema coverage.

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

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

The description clearly states the tool creates a broadcast channel or supergroup, with specific flags distinguishing the two. This is an explicit verb+resource combination that differentiates it from sibling create_* tools like create_invite_link or create_topic.

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

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

No guidance is provided on when to use this tool versus alternatives such as migrate_chat or create_folder. There is no mention of prerequisites, exclusions, or specific use cases beyond the inherent creation action.

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 only openWorldHint=true in annotations, the description adds useful non-obvious behavior: 'id is auto-assigned to the next free slot 2..255.' This goes beyond the schema and annotations. It does not describe return values or failure modes, but the open-world mutation aspect is already hinted by the annotation.

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: two short sentences with no filler. It front-loads the primary purpose and adds a useful clarifying parenthetical, so 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?

Given this tool has 12 parameters, no output schema, and only an openWorldHint annotation, the description is far too minimal. It provides no guidance on how filter parameters combine, defaults when omitted, title constraints, or the expected result, making it incomplete for correct 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%, and the description does not explain any of the 12 parameters. While names like excludeRead, includeBots, and pinnedPeers are somewhat self-explanatory, the semantics of peer arrays, interactions between include/exclude filters, and default values are left undocumented.

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

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

The description clearly states the verb 'Create' and the resource 'dialog folder', with the parenthetical '(chat filter)' adding domain context. It is easily distinguished from sibling tools like edit_folder, delete_folder, and reorder_folders.

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 use case is implied by 'Create a new dialog folder,' but there is no explicit guidance about when to use this tool versus alternatives, nor any mention of prerequisites or conflicts with existing folders. The context is clear but lacks exclusions or alternative recommendations.

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 only include openWorldHint, with no readOnly or destructive hints, so the description must disclose side effects. It only says 'generate' without mentioning permissions, irreversibility, rate limits, or what happens to existing links. This is similar to the TDQS 2.9 example where mutation tools require more transparency.

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

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

A single, front-loaded sentence precisely conveys the tool's core function and options without redundancy. Every word contributes, making it highly concise and well-structured.

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

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

With 6 parameters, no output schema, and minimal annotations, this description is notably incomplete. It does not mention the return value (the invite link), prerequisites for the `peer` parameter, or how the options interact. It also provides no context about when to create versus revoke links, leaving the agent with significant 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 only 33% (expireDate and requestNeeded have descriptions). The description adds meaning for expireDate, usageLimit, and requestNeeded via 'expiry, usage cap, and join-request gate', but it omits the required `peer` param and optional `title`/`accountId`. For expireDate and requestNeeded, it mostly repeats the schema descriptions, so the added value is minimal.

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

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

The description clearly states the action ('Generate a new invite link') and distinct resource, making its purpose unmistakable. It also mentions key customization options (expiry, usage cap, join-request gate) that differentiate it from sibling tools like list_invite_links and revoke_invite_link.

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

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

No explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. While the name implies creation, the description lacks context such as 'use this instead of list_invite_links when you need a new link' or notes about required peer type.

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 only the cryptic 'openWorldHint' annotation, the description carries the burden of behavioral disclosure. It mentions the prerequisite of a forum-enabled supergroup but fails to state permissions required, what happens if the peer is not forum-enabled, or any side effects. This is a minimal disclosure for a potentially mutating action.

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

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

The description is a single, front-loaded sentence with zero waste. It efficiently communicates the core action and the key constraint without redundant phrasing.

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

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

For a tool with 5 parameters, no output schema, and a vague annotation, the description is too sparse. It does not explain the peer parameter format, the return value, how optional icon parameters are used, or any prerequisite beyond 'forum-enabled'. This leaves significant gaps 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 40%, leaving peer, title, and accountId undocumented. The description adds no elaboration on any parameter, so it does not compensate for the low coverage. Users are left guessing the format or semantics of the crucial required 'peer' parameter.

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

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

The description uses a specific verb ('Create'), a resource ('topic'), and a key qualifier ('forum-enabled supergroup'), making the tool's purpose unambiguous. It clearly distinguishes this from sibling tools like edit_topic and list_topics.

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

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

The description implies that this tool should be used only when targeting a forum-enabled supergroup, giving clear context. However, it does not explicitly state when not to use it or mention alternatives such as edit_topic or list_topics, so it stops short of full exclusion 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?

Annotations already declare destructiveHint=true, so the description does not need to restate destructiveness. It adds value by specifying that deletion is permanent and restricted to the creator, which are useful behavioral traits beyond the annotations.

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

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

The description is a single concise sentence that conveys the core action, permanence, and authorization. Every word earns its place, and the title adds complementary scope ('channel or supergroup') without redundancy.

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

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

For a tool with two unannotated parameters and no output schema, the description leaves unanswered questions: what format is 'peer'? What role does 'accountId' play? What is the return value? The annotation only covers the destructive nature, so the description is incomplete for an agent to 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?

The schema has zero description coverage for its two parameters (peer, accountId), and the description provides no explanation of what these parameters mean or how they relate to the channel. The description fails to compensate for the low schema coverage, leaving the agent without parameter 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 ('delete') and resource ('channel'), and adds the permanence aspect ('permanently delete') and the access constraint ('creator only'). This clearly distinguishes it from sibling tools like leave_channel or delete_messages.

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

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

The description conveys clear context: this is for permanent deletion by the creator. However, it does not explicitly mention when not to use it or suggest alternatives such as leave_channel, so it stops short of full guidance.

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

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

Annotations already indicate destructive and open-world behavior. The description adds only the resource scope ('contact book'), which is apparent from the title, and does not disclose additional side effects or irreversibility beyond what annotations 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 one-sentence description is extremely concise and clearly conveys the tool's primary purpose, with no redundant wording. It is well-structured and 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?

The description is minimal and does not cover important operational context such as parameter meanings, permanence, side effects, or return values. Although annotations provide some safety signals, the lack of parameter details and usage guidance leaves significant 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?

Schema description coverage is 0% and the description does not mention the 'users' or 'accountId' parameters, their types, or how to format user identifiers. The description adds no semantic value beyond 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 clearly states the action ('Remove') and the resource ('users from the contact book'), which distinguishes it from other delete tools like delete_messages or delete_channel. It is specific and directly matches the title.

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, prerequisites, or alternatives. The description only states the basic operation, leaving the agent to infer usage solely from the name and title.

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 annotations already indicate destructiveHint: true, but the description adds no further behavioral context (e.g., permanence, effect on contained dialogs, or required permissions). It is consistent with annotations but does not enrich the operational understanding.

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 that directly states the action and object, with no redundant words. It is concise and front-loaded, earning 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 tool is simple, but the description lacks details about side effects (e.g., what happens to dialogs in the folder) and does not mention the accountId parameter. It is minimally viable for a one-line delete operation but leaves gaps for 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%, and the description merely states 'by id' without elaborating on what the id refers to or explaining the optional accountId parameter. The description adds no meaning beyond the parameter names already present in the schema.

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

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

The description uses a specific verb ('Remove') with a clear resource ('a folder') and identifier ('by id'), distinguishing it from sibling folder tools like create_folder, edit_folder, and reorder_folders. The title 'Delete a dialog folder' reinforces this.

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, nor are any prerequisites or exclusions mentioned. The description only states the action, leaving the agent to infer usage from the function name and 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 already mark this as destructive, but the description adds the crucial revoke behavior and its default value, plus the 'where possible' caveat. This goes beyond the structured metadata without contradicting it.

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

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

Two short sentences front-load the core purpose and then add the most important behavioral detail. No redundant words or repetition of schema information.

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

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

The tool is relatively simple and annotations cover the destructive nature. Still, the description omits the meaning of peer and accountId, which are essential for executing the call correctly. The return value and error cases are not described, but no output schema exists, so some burden remains on the description.

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

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

With 0% schema description coverage, the description must explain all parameters. It explicitly clarifies revoke and indirectly messageIds, but leaves peer and accountId completely undescribed. This partial coverage is insufficient for a 4-parameter tool with no 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 uses the specific verb 'delete' with resource 'messages by id', clearly distinguishing it from sibling tools like edit_message or delete_story. The id qualifier adds precision about how messages are targeted.

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

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

The phrase 'by id' implies the tool is for deleting specific messages already acquired via list/search/get operations, providing clear context. However, it does not explicitly state when not to use it or mention alternatives like delete_saved_history, so it lacks explicit exclusions.

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

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

Annotations already mark destructiveHint=true, but the description adds meaningful context by stating 'Irreversible' and clarifying the exact impact ('Wipe all messages... from a single origin peer'). This goes beyond the annotation by specifying the scope of destruction, though it does not mention auth requirements or other side effects.

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

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

The description is two short sentences that front-load the primary action and resource, with the parenthetical adding necessary specificity and 'Irreversible' adding crucial risk info. Every word earns its place, making it highly concise and well-structured.

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

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

The tool has 5 parameters and no output schema, yet the description omits any guidance on the optional filtering parameters (maxId, maxDate, minDate) and accountId. It also does not describe what happens after deletion (e.g., return value). For a destructive tool with partial-deletion options, this is insufficient to ensure correct and safe 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 coverage is only 40% (peer and maxId have descriptions; maxDate, minDate, and accountId do not). The tool description provides no parameter explanations and even says 'Wipe all messages,' which conflicts with the existence of maxId/maxDate/minDate filters that allow partial deletion. This could mislead the agent into thinking the tool always deletes everything, without explaining how to limit the deletion.

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 ('Wipe') and clearly identifies the resource ('Saved-Messages sub-dialog') and scope ('forwards from a single origin peer'). It also distinguishes this from sibling tools like delete_messages and delete_user_history by targeting a sub-dialog of forwards, making its purpose unambiguous.

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

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

The description implies when to use the tool (clearing a specific saved-messages sub-dialog) but does not explicitly compare it to alternatives such as delete_messages or delete_user_history, nor does it state when not to use it. There is no exclusion or prerequisite guidance, so usage context is clear but underdeveloped.

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 already declare destructiveHint=true, indicating this is a destructive operation. The description adds the constraint that only stories 'previously posted' by the user are affected, which is a useful scoping detail. However, it does not disclose permanence, authorization requirements, or side effects. No contradiction with annotations.

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

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

The description is a single, short sentence (5 words) that is front-loaded with the main action. It is very concise. However, it is so minimal that it borders on under-specification, though it does convey the core purpose effectively.

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 3 parameters (one required) and no output schema, the description is incomplete. It omits parameter semantics, whether the deletion is permanent, how story IDs are used, and any effect of the peer or accountId parameters. The annotations cover destructiveness, but the description alone is insufficient for safe and correct 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%, and the description does not explain any of the parameters (peer, storyIds, accountId). It offers no additional meaning beyond the parameter names and types in the schema. This is a significant gap, as the description should compensate for the lack of schema-level 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 states the action clearly: 'Remove stories you previously posted.' It identifies the resource (stories) and the verb (remove). It does not explicitly distinguish from sibling tools like delete_messages, but the resource is distinct. There is slight ambiguity about whether the 'previously posted' restriction is accurate, given the 'peer' parameter.

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 remove stories you have posted. It does not explicitly mention alternatives or when not to use it. The 'previously posted' scope provides some contextual guidance, but there is no explicit comparison to other deletion or management 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?

Annotations already declare destructiveHint=true and openWorldHint=true, aligning with 'Wipe every message'. The description adds scope (channel/supergroup) but does not mention irreversibility, permission needs, or the effect on the user's access, which would provide additional transparency beyond the annotations.

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

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

The description is a single clear sentence with no filler words. It front-loads the primary action and scope, making it easy 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 tool with a simple destructive operation and no output schema, the description captures the essential context: what gets deleted and in which context. However, it omits parameter semantics for accountId and any behavioral caveats, which keeps it slightly shy of a full 5.

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

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

Schema description coverage is 0%, so the description must compensate for parameter semantics. It hints that 'user' names the message author and 'peer' identifies the channel/supergroup, but it does not clarify the meaning or format of 'accountId', nor does it explain the relationship between the parameters beyond implicit mapping.

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 ('Wipe') and resource ('every message a given user has posted in the channel/supergroup'), clearly distinguishing this from sibling tools like delete_messages or delete_saved_history. It conveys both the action and scope effectively.

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 (removing all messages by one user in a group), but it does not explicitly state when to prefer this tool over alternatives such as delete_messages or restrict_user. No exclusions or prerequisites are given.

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

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

Annotations already provide idempotentHint and openWorldHint, which cover repeatability and external effects. The description adds the action but leaves ambiguity about whether 'all admin rights' are scoped to the given peer or global across chats. It doesn't disclose failure behavior or permission requirements, but the annotation coverage partially compensates.

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, straightforward sentence that conveys the core function without any filler. It is front-loaded and every word contributes to the 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 mutating tool with no output schema and 0% parameter documentation, this description is insufficient. It lacks details about required permissions, the precise scope of 'all admin rights' (per peer vs global), return behavior, and edge cases such as demoting a non-admin. The short description leaves too many critical gaps for an agent to use 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 does not compensate. It mentions 'user' but fails to explain the 'peer' and 'accountId' parameters. An agent would have to infer that 'peer' refers to a chat/channel and 'accountId' to the acting user's account, which is not stated anywhere.

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 specifies the action ('Remove'), the object ('all admin rights'), and the target ('a user'). It unambiguously distinguishes from siblings like promote_admin and restrict_user, making the tool's function immediately obvious.

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

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

No guidance is provided on when to use this tool versus alternatives such as restrict_user or demote in different scopes. There is no mention of prerequisites (e.g., being a group admin) or when not to use it. The usage context is only implied by the tool's name and 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?

The description adds behavioral details beyond annotations: the download destination directory, an environment variable override, and the return of the absolute path. This is consistent with readOnlyHint (no remote state mutation) and provides practical 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?

Two concise sentences, front-loaded with the core purpose, and every word adds value. No redundant or extraneous information.

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

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

For a straightforward download tool, the description covers the key operational aspects: where files are stored, how to override the path, and what is returned. It lacks edge cases (e.g., no media attached) but is adequate given the simple nature and the absence of an output schema.

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

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

Schema description coverage is 0%, and the description does not explain the meaning or purpose of peer, messageId, or accountId. The parameter names are somewhat self-explanatory, but the description fails to add any clarifying value, leaving a significant 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 'download' and resource 'media attached to a message', clearly distinguishing it from siblings like download_profile_photo. It also specifies where files land, reinforcing the purpose.

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

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

The intended use is clear: download media from a message. It does not explicitly state when to avoid using it or compare to alternatives, but the context is sufficiently clear without being misleading.

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 declare readOnlyHint=true and openWorldHint=true. The description adds a concrete behavioral detail: 'Saved under /root/.telegram-agent/downloads.' This clarifies the destination and side-effect of saving a file, going beyond the annotations. It does not cover error cases but adds meaningful 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?

Two short sentences, each serving a purpose. The verb-fronted first sentence states the action, and the second provides the save location. No 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?

For a simple read-only tool with one required parameter, the description covers the core behavior and output location. It omits edge cases like missing profile photos, but given the low complexity and existing annotations, it is reasonably complete.

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

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

Schema coverage is 0% and the description does not explain the parameters. 'peer' is only vaguely associated with 'user/chat/channel,' and 'accountId' is completely unaddressed. The description fails to compensate for the lack of 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 clearly states the tool's action: 'Download the profile photo of a user/chat/channel.' This specifies the verb (download) and resource (profile photo) and differentiates it from siblings like download_media or set_profile_photo.

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

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

The description implies the tool is for profile photos but does not explicitly state when to use it over alternatives like download_media. There is no mention of exclusions or preferred contexts, leaving some ambiguity for the 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?

The description mentions the 255-character limit (already in schema) and the target resource, but it does not disclose additional behavioral traits like permission requirements or whether the operation overwrites existing text. With openWorldHint and idempotentHint annotations, the description adds minimal context beyond them.

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

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

The description is a single concise sentence that is immediately clear and free of extraneous information.

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

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

The tool is simple and the description covers the core behavior. However, there is no output schema and the description does not mention return values or potential errors, but this is a minor gap for a setter operation.

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

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

Schema coverage is 0%, so the description must compensate. It explains what 'about' is (the description text) and implies 'peer' is a channel/supergroup, but it does not clarify the format of peer or the purpose of accountId. For 3 parameters, this is insufficient.

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

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

The description clearly identifies the tool's purpose: setting the description of a channel/supergroup. It uses a specific verb ('set') and resource ('description of a channel/supergroup'), and it is distinct from sibling tools like edit_title and update_profile.

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

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

The description clearly states the tool is for channel/supergroup descriptions, which implies when to use it. However, it does not explicitly mention alternatives or exclusions, such as 'use edit_title for the title'.

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

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

The description says 'Replace the rules' but does not clarify whether unspecified fields are reset to defaults or whether it's a partial update. It lacks information about permissions, error behavior if the folder doesn't exist, or side effects. Annotations openWorldHint and idempotentHint provide some context but do not cover these aspects.

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 concise with two sentences, front-loading the main action. However, the second sentence about `id` being required is redundant with the schema and could be omitted without loss.

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 13 parameters, no output schema, and mutation semantics, the description is far too minimal. It does not explain what 'rules' means, how the boolean/array parameters map to folder filtering behavior, or what happens on execution. Annotations partially compensate but are insufficient for a tool of this complexity.

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

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

Schema description coverage is 0%. The description only mentions `id` is required, which is already in the schema's required array, adding no new meaning. The other 12 parameters (e.g., excludeRead, includeBots, pinnedPeers) are not described, leaving the agent to infer their semantics from names alone.

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: 'Replace the rules of an existing folder,' identifying both the verb and resource. It distinguishes from siblings like create_folder and delete_folder by emphasizing 'existing,' but 'rules' is somewhat ambiguous without schema context.

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

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

Usage is implied through the phrase 'existing folder' and the requirement of `id`, suggesting this is for editing an already-created folder. However, no explicit alternatives or exclusions (e.g., use create_folder for new folders, reorder_folders for ordering) are provided.

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

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

The idempotentHint and openWorldHint annotations already cover retry safety, lowering the bar. The description adds that the message must already have been sent, but it does not disclose typical limitations like ownership restrictions or age limits.

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

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

The description is a single, concise sentence that immediately conveys the core action. It contains no filler and is appropriately sized for a simple tool.

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

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

With 6 parameters and no output schema, the one-sentence description is insufficient. It omits important context such as return values, permissions, or behavioral caveats, making it incomplete for a production messaging API.

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 implies the 'text' parameter but provides no explanations for peer, messageId, parseMode, linkPreview, or accountId, leaving significant gaps for a 6-parameter 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 clearly states the tool's function: editing the text of a previously sent message. It uses a specific verb (edit) and resource (message text), distinguishing it from sibling tools like send_message, delete_messages, and pin_message.

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

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

There is no guidance on when to use this tool versus alternatives such as sending a new message or deleting and resending. No exclusions or prerequisites are mentioned.

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

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

Annotations include openWorldHint and idempotentHint, which already indicate the tool modifies external state and is idempotent. The description adds the useful context that the photo can come from a local path or URL and implies replacement of the existing avatar. However, it does not disclose potential side effects like whether the old avatar is deleted or if specific permissions are required.

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

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

The description is a single, clear sentence that is immediately understandable. It avoids unnecessary words and gets straight to the point, making it easy 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?

The tool is simple but lacks essential context. Required parameters 'peer' and 'path' are not explained, the difference from set_profile_photo is not stated, and there is no output schema or additional behavior described. An agent would struggle to know what values to pass for 'peer' and 'accountId'.

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

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

With 0% schema description coverage, the description must explain parameters. It only clarifies 'path' by stating it can be a local path or URL, but leaves 'peer' and 'accountId' unexplained. 'peer' is required and critical for selecting the chat/channel, so the lack of explanation is a significant 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 'Upload a new avatar photo from a local path or URL' clearly states the action (upload) and the resource (avatar photo). The title 'Change chat / channel avatar' clarifies the target, distinguishing it from user profile photo tools like set_profile_photo. However, the description alone does not explicitly mention 'chat/channel', so it relies on the title for full sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is for chat/channel avatars specifically, nor does it contrast with set_profile_photo or other avatar-related tools. No exclusions or prerequisites are stated.

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

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

Annotations declare idempotentHint and openWorldHint, which already communicate safety and side-effect behavior. The description adds the constraint about supported peer types, but gives no further behavioral details like error cases or whether the title change is restricted by permissions. No contradiction with annotations.

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

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

The entire description is a single brief sentence that immediately states the action and its scope. No filler words; each clause adds relevant information.

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

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

With no output schema and minimal description, the tool fails to clarify parameter semantics (peer and accountId) and potential constraints. It is too sparse for practical use despite the annotations.

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

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

The input schema provides no parameter descriptions (0% coverage), and the tool description does not explain the 'peer' or 'accountId' parameters. Only 'title' is self-explanatory, leaving the user to guess how to format peer references.

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 'Set a new title' and explicitly lists supported peer types (channels, supergroups, basic groups), which clearly differentiates it from sibling tools like edit_topic or edit_about.

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 indicates the tool applies to channels, supergroups, and basic groups, providing clear context for when to use it. However, it does not explicitly state when not to use the tool or mention alternatives, such as edit_topic for topic titles.

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

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

The description does not add behavioral context beyond the actions themselves. It does not explain whether actions can be combined, what happens if both closed and hidden are set, or any side effects. With annotations openWorldHint and idempotentHint, the safety profile is partially covered, but the description adds no extra value beyond the annotation.

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

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

The description is a single, front-loaded sentence that uses action-packed verbs with no wasted words. It is highly concise and structured effectively, listing the four main capabilities in a compact enumeration.

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 7 parameters, no output schema, and annotations that are present but minimal. The description is too brief to be contextually complete: it omits required parameter semantics (peer, topicId) and does not describe return format, permission requirements, or the effect of omitting optional fields. For a tool with this complexity, the description 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 0%, so the description must compensate. It maps 'rename' to title, 're-icon' to iconEmojiId, 'close' to closed, and 'hide' to hidden, providing meaning for 4 of 7 parameters. However, it does not explain peer, topicId, or accountId, which are essential for identifying the target topic. The partial coverage adds value but leaves gaps.

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 'Rename / re-icon / close / hide a topic' clearly states the specific actions and resource, distinguishing it from sibling tools like edit_title (chat/channel title) and create_topic (creating a topic). The verb list is specific and unambiguous.

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

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

There is no explicit guidance on when to use this tool versus alternatives. It does not mention that it is only for existing forum topics or how it differs from edit_message or edit_title. The usage is only implied by the name and description, lacking clear context 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?

The only annotation is openWorldHint: true, which is vague. The description does not disclose whether forwarding copies messages (leaving originals intact), any authentication requirements, rate limits, or side effects on the source/destination dialogs. This lack of behavioral detail goes beyond what annotations convey.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It conveys the core purpose 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?

There is no output schema, so the description should explain what the tool returns, but it does not. It also omits the 100-message limit for messageIds and other contextual details such as whether forwarding is available across different dialog types. The description is too sparse for a tool with six parameters.

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

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

Schema coverage is only 17% (only dropAuthor has a description), so the description must compensate. It clarifies that fromPeer and toPeer refer to dialogs and that messageIds are the messages being forwarded, but it leaves silent, accountId, and the exact meaning of messageIds implicit. This is partial compensation but not thorough.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Forward messages from one dialog to another.' This distinguishes it from siblings like send_message or edit_message, which serve different purposes.

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

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

There is no guidance on when to use this tool versus alternatives such as send_message, nor are any prerequisites or exclusions mentioned. The description simply states what it does, leaving the agent to infer when it should be selected over similar 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?

Annotations declare readOnlyHint and openWorldHint, so safety is already covered. The description adds meaningful behavioral context with 'Set fields in events to true to include those categories; leave empty to include everything,' clarifying default filter behavior. However, it doesn't disclose limit defaults or return ordering.

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 sentence, front-loaded with the core purpose. It is concise without any filler, making it easy 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?

With 5 parameters, a nested object, and no output schema, the description leaves significant gaps: it doesn't explain that `peer` is required, what 'recent' means, or the semantics of `limit` and `accountId`. Even with annotations providing safety context, the description is insufficient for correct 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 coverage is only 20% (only 'query' has a description). The description compensates by explaining the `events` object semantics, but it leaves `peer`, `limit`, and `accountId` unexplained, relying on name inference. The `events` clarification is useful but the overall compensation is incomplete.

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 'Return recent admin events' with a specific verb and resource, distinguishing it from all sibling tools. No other tool in the list targets admin logs, making this highly unambiguous.

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

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

The description implies usage for retrieving admin events but does not explicitly state when to use this tool versus alternatives or provide any exclusions. It offers clear context but no explicit 'when to use' guidance beyond the core purpose.

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 already declare readOnlyHint=true (safe read) and openWorldHint=true. The description adds transparency by listing the specific info fields returned (about, participants count, linked chat, slow mode), which is useful context beyond the annotations. It does not mention any side effects, consistent with a read-only 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, front-loaded sentence that directly states the purpose and examples. Every word is useful, with no redundancy or wasted content.

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

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

There is no output schema, so the description carries the burden of informing the agent about the return value. It lists some returned fields but does not exhaustively describe the output shape or the purpose of 'accountId'. For a simple read-only info tool, the description is adequate but incomplete.

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

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

Schema description coverage is 0%, so the description must compensate for parameter documentation. It implicitly explains the 'channel' parameter by referencing 'a channel or supergroup', but the 'accountId' parameter is not mentioned at all, leaving a gap. The description only partially compensates for the missing schema descriptions.

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

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

The description clearly states the tool's function: 'Return extended info for a channel or supergroup', with specific examples of the information returned (about, participants count, linked chat, slow mode). This distinguishes it from sibling tools like 'get_user_info' (for users) and other channel mutation tools.

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

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

The description implies usage when channel/supergroup extended info is needed but does not explicitly state when to use it versus alternatives. No exclusionary or alternative guidance is provided, making the usage context implicit rather than explicit.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=true, indicating a non-destructive read operation. The description adds the context that the result is 'server-suggested' and a 'default emoji set,' which implies it is not user-specific and may be constant across accounts. However, it doesn't disclose whether the set is ordered, localized, or subject to changes, leaving some transparency gaps. The annotations lower the bar, and the description provides marginal additional 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 concise one-line phrase, front-loaded with the key term 'server-suggested.' It wastes no words, but it is not a complete sentence, which slightly reduces clarity. Still, it earns its place by adding the 'server-suggested' qualifier.

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

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

The tool is simple, but with no output schema, the description should clarify what the response looks like (e.g., an array of emoji codes). It also fails to explain the optional accountId parameter or any edge cases. The annotations cover safety, but the description is incomplete for an agent to fully understand the return value and parameter behavior.

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

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

The input schema has a single optional 'accountId' parameter with 0% description coverage. The tool description does not mention accountId at all, leaving the agent to infer its purpose from the name alone. It is unclear whether providing accountId changes the returned set or what the default behavior is when omitted. Given the low schema coverage, the description should have compensated but does not.

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

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

The title 'List default Saved-tag reactions' provides a clear verb+resource, and the description adds context by specifying 'Server-suggested default emoji set for Saved-Messages tagging.' This distinguishes it from sibling tools like get_saved_reaction_tags, which likely return user-defined tags, by emphasizing 'server-suggested default.' However, the description itself is a noun phrase rather than a full action statement, relying on the title for the verb.

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

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

The description gives no guidance on when to use this tool versus alternatives such as get_saved_reaction_tags or set_default_reaction. It neither states explicit when-to-use conditions nor provides exclusions. The only hint is the word 'default,' but this is not enough to guide tool selection.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds the `@bot query` syntactic form, which is useful, but it does not disclose behaviors such as pagination via offset or how peer affects allowed result types (the latter is in the schema but not the description). This is acceptable but not rich.

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

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

The description is a single, well-structured sentence that is front-loaded with the action and resource. No wasted words or unnecessary repetition.

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

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

The core purpose is clear, but the description lacks details about return format, pagination, and parameter semantics. Given no output schema and low schema coverage, the description leaves operational gaps, making it minimally viable but incomplete.

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

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

Schema description coverage is only 20%, so the description should compensate. It implicitly explains bot and query via the `@bot query` form, but does not clarify offset, accountId, or the meaning of peer beyond what the schema already provides. This is insufficient for a 5-parameter tool with mostly undocumented parameters.

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

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

The description clearly states the tool runs an inline bot query (the `@bot query` form) and returns results, using a specific verb and resource. This distinguishes it from sibling search/message tools, which operate on messages or accounts rather than inline bot queries.

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

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

No guidance is provided on when to use this tool versus alternatives. The description only states what it does, not when it should be selected (e.g., for inline bot results vs. regular search), and no exclusions or alternative tool references are given.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the 'chosen account' scoping nuance but does not disclose return format, error behavior, or authentication requirements beyond the phrase 'authenticated user'.

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, front-loaded with the action verb 'Return' and no unnecessary words. Every word contributes to the 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 getter with annotations, the description covers the core purpose adequately. Minor gaps remain: it does not state what happens if accountId is omitted or whether authentication is required, but these are somewhat implied.

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 one optional string parameter (accountId) with no description (0% schema coverage). The description only hints at 'chosen account' but does not explain the parameter's purpose, format, or behavior when omitted, leaving ambiguity.

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

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

The description clearly states the tool returns the profile of the authenticated user for a chosen account, using a specific verb and resource. This distinguishes it from siblings like get_user_info, which likely handles arbitrary users.

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 (to get the current user's profile) but provides no explicit alternatives, exclusions, or prerequisites. It doesn't mention when to use this over related tools like get_user_info or login.

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 readOnlyHint and openWorldHint annotations already establish the safety profile, so the description does not need to repeat that. It adds minimal behavioral context beyond the fetch action, such as not disclosing error handling for invalid IDs or the return shape for multiple messages, but it does not contradict the annotations.

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

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

A single sentence with no filler, directly stating the action and scope. Ideal size and front-loaded structure.

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

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

For a simple read-and-fetch operation, the description covers the core functionality. It lacks explicit output shape, but without an output schema the 'Fetch' verb sufficiently implies the return. Given the tool's low complexity, the description is adequate.

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

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

Schema description coverage is only 33% (only 'peer' has a description). The description confirms ids are message IDs but does not clarify accountId or provide details about the ids array format beyond what minItems/maxItems already convey. It fails to compensate for the low schema coverage.

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

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

The description uses the specific verb 'Fetch' and identifies the resource (messages), scope (from a dialog), and method (by their ids). This clearly distinguishes it from sibling tools like list_messages or search_messages, which serve different purposes.

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

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

The description clearly implies usage when the agent has specific message IDs and knows the dialog (peer). However, it does not explicitly exclude alternatives or name sibling tools like list_messages, stopping short of a 5.

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

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

Annotations (readOnlyHint, openWorldHint) cover safety and volatility; the description adds 'current' and batch support, but does not disclose response structure or behavior for invalid message IDs. It does not contradict annotations.

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

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

A single, front-loaded sentence that conveys the core purpose without excess words.

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

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

For a simple read operation with no output schema, the description is adequate but omits return-value structure and usage guidance; given three parameters and openWorldHint, more detail would improve completeness.

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

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

With 0% schema description coverage, the description partially compensates by linking 'messages' to messageIds and 'dialog' to peer, but accountId is not explained, and parameter formats are left unspecified.

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 'Fetch' with the resource 'current reactions' and specifies the scope 'for one or more messages in a dialog', clearly distinguishing from write operations like send_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?

The scope (dialog messages) provides context but there is no explicit guidance on when to use this tool over alternatives such as send_reaction or get_message. The name implies read-only usage, but no when-not-to-use or alternative references are given.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is known. The description adds scope ('across channels') but no additional behavioral traits such as authentication needs, rate limits, or side effects, which is acceptable given the annotations.

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

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

The description is a single sentence that is direct and front-loaded with the action and object. There is no redundant or filler content, 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 tool is simple (one optional parameter, no output schema), and the description gives a high-level return statement. However, it omits parameter semantics and the return structure, making it only partially complete for an agent to invoke correctly without additional context.

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

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

The input schema has one parameter (accountId) with no description, and schema description coverage is 0%. The description mentions nothing about this parameter, leaving the agent to guess its meaning and whether it is required. The description fails to compensate for the lack of 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 uses a specific verb ('Return') and resource ('boost slots') with scope ('across channels'), making the tool's function immediately clear. It also implicitly distinguishes itself from the sibling 'apply_boost' by being the read-only counterpart.

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 (to see current available boost slots) but does not explicitly state when to use this versus alternatives like 'apply_boost', nor provide exclusions or prerequisites. The context is somewhat clear but guidance is minimal.

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 already declare readOnlyHint=true and openWorldHint=true, which cover the safety profile. The description adds minimal behavioral context, simply stating the return value. It does not disclose pagination, authentication, or the role of the optional accountId.

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

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

The description is a single concise sentence that front-loads the verb 'Return' and states the resource. No extra words, perfectly scoped.

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 a simple getter with a read-only annotation, so the description is mostly adequate. However, without an output schema, the return format is unclear, and the optional accountId is not explained. The description is minimal but sufficient for the core function.

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 contains one parameter (accountId) with no description, and the description does not mention it. Schema description coverage is 0%, so the description fails to explain how accountId affects the call or whether it defaults to the current user.

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 ('Return') with a clear resource ('the user's installed sticker sets'), which distinguishes it from sibling tools like install_sticker_set and add_recent_sticker. It matches the title and leaves no ambiguity about the operation.

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

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

The description provides no when/when-not guidance or alternative tool references. It is clear that this is a read operation for listing sticker sets, but there is no explicit comparison to install_sticker_set or add_recent_sticker.

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 readOnlyHint annotation already indicates a safe read operation, but the description adds no further behavioral details such as return format, fallback defaults, or the role of accountId. Without an output schema, this leaves the agent without critical information about what to 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 description is a single, concise sentence that front-loads the verb and resource. While efficient, it could be slightly more informative without becoming verbose, but it earns its place as a clear statement of purpose.

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

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

For a simple getter, the description is minimal, but it omits explanation of accountId and the return value. With no output schema and low schema coverage, the description does not adequately compensate, making it incomplete for practical 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 0%, and the description only mentions 'peer' without explaining its format or meaning. The optional accountId parameter is entirely omitted, providing no semantic value beyond the schema's bare field 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 'Return notification settings for a peer' uses a specific verb and resource, clearly indicating a read operation scoped to a peer. It distinguishes itself from sibling tools like set_notify_settings by focusing on retrieval rather than modification.

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

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

No guidance is provided on when to use this tool versus alternatives such as set_notify_settings or mute_peer. The description lacks explicit context, exclusions, or prerequisites, 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?

Annotations already indicate read-only and open-world behavior. The description adds value by clarifying the exact return fields (role, rights, join date), which is useful for understanding the tool's output. It does not disclose edge cases like missing participants, but the read-only annotation covers the main safety concern.

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 clear sentence, front-loaded with the action 'Return'. No wasted words, easily scannable, and appropriately sized for the simplicity of the tool.

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

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

For a simple read-only tool with good annotations, the description adequately states the purpose and return value. It lacks detailed parameter format guidance, but the tool is relatively straightforward and the existing sibling tools (e.g., list_participants) likely cover more complex cases. Overall, it is mostly complete for a single participant lookup.

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

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

With zero schema description coverage, the description offers minimal semantic help: it clarifies that 'peer' refers to the channel/supergroup and 'user' is the target user. However, it does not specify accepted identifier formats (ID, username, phone) or the optional accountId parameter, leaving significant ambiguity 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?

The description uses the specific verb 'Return' and names the exact resource properties (role, rights, join date) for a single participant, which clearly distinguishes it from list_participants and other participant-related tools. The scope 'in a channel/supergroup' further clarifies the target context.

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

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

The description specifies the context 'in a channel/supergroup' and the singular nature ('one user'), making it clear when this tool is appropriate. However, it does not explicitly name alternatives or when-not-to-use cases, so it falls short of an explicit guideline.

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

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

Annotations readOnlyHint=true and openWorldHint=true already declare a safe read operation. The description adds the 'active' filter and 'one peer' scope, providing some behavioral context beyond the annotations. However, it does not disclose other behaviors like handling of empty results or pagination.

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

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

The description is a single, front-loaded sentence with no redundant phrases. It efficiently conveys the verb, resource, and scope.

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 2-parameter read-only tool with no output schema, the description is minimal. It omits crucial parameter semantics, especially for accountId, and does not explain what 'active' means or how the response is structured. The core purpose is clear, but the definition is incomplete 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 0%, and the description does not compensate. It vaguely implies the 'peer' parameter via 'one peer', but the 'accountId' parameter is completely unexplained. No parameter details or format hints are provided.

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

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

The description 'Return active stories posted by one peer' clearly specifies the action (return), resource (stories), and scope (one peer). It distinguishes itself from sibling list_stories by explicitly limiting to a single peer.

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

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

No guidance is provided on when to use this tool versus alternatives like list_stories or view_story. The description does not mention any exclusions or alternative tools, leaving the agent to infer usage.

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 already declare readOnlyHint=true, and the description is consistent with that. The description adds only the scope 'poll message' but does not disclose additional behavioral traits such as permission requirements or behavior for closed polls. It meets the baseline with annotations present but adds limited value beyond them.

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

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

The description is a single, front-loaded sentence that conveys the key information without any wasted words. It is concise and well-structured.

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

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

There is no output schema and the description does not describe the return structure of the vote tally (e.g., per-option counts, total votes). With zero schema coverage and no parameter descriptions, the tool definition lacks necessary invocation details. The presence of readOnlyHint and openWorldHint annotations partially offset the safety concerns, but the description is still under-specified for a 3-parameter tool.

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

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

Schema coverage is 0% and the description does not explain what 'peer', 'messageId', or 'accountId' mean. The phrase 'poll message' gives a minimal hint that messageId refers to a poll message, but the description fails to compensate for the complete lack of parameter documentation. An agent would have to rely on sibling tool conventions to understand the parameters.

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

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

The description uses a specific verb 'Fetch' and a clear resource 'current vote tally for a poll message', making the tool's purpose unmistakable. It also distinguishes itself from sibling tools like send_poll, vote_poll, and close_poll by focusing on reading results rather than creating or modifying polls.

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

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

The description clearly indicates the tool is for retrieving poll results, so an agent can infer when to use it. However, it does not explicitly compare with alternatives like get_message or get_message_reactions, nor does it state when not to use this tool. This is clear context without 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, which cover the safety profile. The description adds the context that the tool returns 'current rules' (not historical) and for 'one' key only, which is a behavioral constraint beyond what annotations provide. However, it does not disclose other details like auth requirements or rate limits, so it meets only the baseline for annotated read operations.

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

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

The description is a single, concise sentence that front-loads the verb 'Return' and immediately states the resource. Every word contributes meaning; there is no fluff or redundancy.

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

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

For a simple read-only getter with no output schema, the description is largely sufficient: it states the function, the resource, and the scope. The missing usage guidance and accountId explanation are gaps, but the tool's simplicity and the presence of readOnlyHint mean the description covers the essential context.

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

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

The description mentions 'one privacy key,' which directly maps to the required 'key' parameter and reinforces that only a single key can be queried at a time. However, it does not elaborate on the optional 'accountId' parameter, and with schema description coverage at 0%, the description only partially compensates for the missing parameter documentation. The enum in the schema helps, but the description adds limited value beyond the schema.

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

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

The description uses the specific verb 'Return' and clearly identifies the resource as 'current rules for one privacy key.' This distinguishes the tool from its sibling set_privacy, which is a mutating counterpart. The purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives like set_privacy, nor does it mention any exclusions or prerequisites. While a getter's usage is somewhat self-evident, the lack of explicit direction makes it minimally useful for an agent deciding between tools.

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

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

The annotations already declare readOnlyHint and openWorldHint, so the bar for added disclosure is lower. The description contributes the domain-specific behavior that these sub-dialogs are groupings by origin peer, which helps the agent understand the result semantics. It does not contradict the annotations.

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

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

The description is a single, front-loaded sentence with no redundant wording. It efficiently communicates the core purpose and a key distinguishing 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?

The description covers the essential 'what' but leaves out important contextual details like the effect of limit and excludePinned, especially given there is no output schema. The openWorldHint and parameter schema partially compensate, but the description alone is only minimally sufficient for an agent to correctly invoke 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?

With 0% schema description coverage and three parameters (limit, accountId, excludePinned), the description provides no explanation of their meaning, behavior, or defaults. The burden falls entirely on the parameter names, which the description does not support.

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 clearly identifies the resource as 'forum-style sub-dialogs inside Saved Messages', with an explanatory clause about grouping by origin peer. This distinguishes it from generic dialog listing tools like list_dialogs.

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

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

The description implies when to use this tool—when you need the sub-dialogs in Saved Messages—but it doesn't provide explicit exclusions or alternative tool references. The context is clear enough for typical use, but it lacks a when-not-to-use statement.

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 already declare readOnlyHint=true and openWorldHint=true, so the safety profile is clear. The description adds the filtering behavior by original sender peer, but does not disclose pagination behavior, return format, or other behavioral details beyond annotations.

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

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

The description is a single concise sentence that is front-loaded with the key action and resource. No wasted words 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?

For a simple read-only pagination tool, the description is adequate but lacks details about return format and pagination behavior. Since there is no output schema and only a basic description, the agent may not know what fields the fetched messages contain or how pagination parameters interact.

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 'peer' has a description). The description clarifies that 'peer' means 'original sender peer', but limit, offsetId, and accountId are left unexplained. With low schema coverage, the description does not adequately compensate for the missing parameter 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?

Description states 'Fetch messages inside one Saved-Messages sub-dialog' with a specific verb and resource, and clearly differentiates from siblings like get_saved_dialogs and search_saved_messages by specifying the sub-dialog scope and filtering by original sender peer.

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 (for fetching messages from a specific saved sub-dialog), but it does not explicitly mention alternatives or give exclusions. No 'use X instead' guidance is provided.

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

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

Annotations declare readOnlyHint=true, and the description adds operational context: it is a premium feature, restricted to the `me` peer, and returns custom titles and counts. This goes beyond the structured annotations without contradicting them.

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

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

The description is a single sentence with no filler. It front-loads the action and result, naming the key constraints.

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

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

For a simple read-only list operation, the description covers the output contents, premium requirement, and peer scope. It does not mention errors or pagination, but given the readOnlyHint and simple schema, it is sufficiently complete. It could benefit from naming sibling tools for disambiguation.

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

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

The schema already documents the peer parameter well ('Scope tags to a saved-dialog... Omit for global Saved tags'), and the description reinforces the `me` peer restriction. However, the accountId parameter is undocumented in both schema and description, and the description adds no syntax details 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 uses a specific verb 'Return' and identifies the exact resource ('reaction-tags' on Saved Messages) with return contents (titles, counts). It clearly distinguishes from siblings like get_default_tag_reactions and update_saved_reaction_tag.

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 states clear constraints: 'Premium feature' and 'works only on the `me` peer', telling the agent when it can be invoked. However, it does not explicitly contrast with alternative tools like get_default_tag_reactions or search_saved_messages.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds the constraint that the story must be 'you posted', which is useful context, but it does not disclose pagination, ordering, or other behavioral details.

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 is appropriately concise for a simple read operation, earning maximum efficiency for size and structure.

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 five parameters, zero schema description coverage, and no output schema, the description is incomplete for agent reasoning. It leaves important semantics unexplained, such as the purpose of 'query' and 'peer', and what the response contains.

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% for five parameters (peer, limit, query, storyId, accountId). The description does not explain any of these parameters, leaving agents without information about their meanings, formats, or required values.

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 'show' with the resource 'viewers of a story', clearly distinguishing it from sibling tools like list_stories and view_story. The phrase 'story you posted' adds ownership context, making the tool's function unambiguous.

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

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

The description implies usage when a user wants to view viewers of their own story, but provides no explicit guidance on when to use this tool versus alternatives like get_peer_stories or view_story. No exclusions or alternative recommendations are given.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that it returns extended profile info like bio and common chats count, which gives some context about the output, but it does not mention error cases (e.g., user not found) or behavior around the optional accountId.

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

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

The description is a single, front-loaded sentence that states the action and gives examples. Every word earns its place, with no redundancy or irrelevant 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?

The tool is relatively simple, but the description lacks details about the accountId parameter, potential errors, and how it differs from sibling tools like get_me. Given the 0% schema coverage and no output schema, more context is needed for full completeness.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only hints at 'user' implicitly through 'for a user', but the 'accountId' parameter is entirely unexplained. This leaves a significant gap in understanding the full parameter 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 clearly states the tool's action ('Return extended profile info') and resource ('for a user'), with examples (bio, common chats count). However, it does not explicitly differentiate from sibling tools like get_me or get_participant, so it stops short of full specificity.

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 offers no guidance on when to use this tool versus alternatives, such as get_me for self or get_participant for chat members. There are no exclusions or alternative tool mentions, leaving the usage context entirely 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?

Annotations already provide openWorldHint and idempotentHint, which convey side-effect potential and idempotent behavior. The description adds no additional behavioral context beyond the surface action 'Install', so it meets the baseline but does not enrich transparency further.

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 is front-loaded with the action and includes a useful example, making it optimally 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?

Given three parameters and no schema descriptions, the description covers only the required parameter and omits the optional ones. There is also no mention of return values or behavior, which is significant since no output schema exists. The description is too sparse to fully guide 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 schema has 0% description coverage, so the description must compensate. It explains 'shortName' with an example, but leaves 'archived' and 'accountId' completely unexplained. This is only partial compensation for the missing schema descriptions.

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

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

The description clearly identifies the action ('Install') and the resource ('sticker set'), with a concrete example of the short name parameter. It is specific and distinguishes this tool from other sticker-related sibling tools like get_my_stickers or add_recent_sticker by focusing on installation.

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

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

The description implies when to use the tool (when you want to install a sticker set by short name) but provides no explicit guidance on alternatives or exclusions. It does not mention any prerequisite or context, so the usage context is only implicitly derived from the action.

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 include idempotentHint but not readOnly or destructive hints, so the description must disclose behavioral traits. It simply says 'Add' without mentioning permissions, potential errors, or side effects beyond the annotations. No additional context is provided.

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 redundant information. It is appropriately sized and front-loaded with the key action.

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