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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action and optional text/alert, but does not mention that this is a required acknowledgment to avoid the Telegram loading indicator, or any constraints (e.g., invalid callback_query_id behavior). It is too terse to convey the 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 concise sentence with no waste. It is front-loaded with the core action and includes the optional parameters in parentheses. However, it is so brief that it borders on under-specification, though it earns a 4 for efficiency.

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

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

Given the tool is a mutation with no annotations and an output schema (which likely describes the result), the description should still cover prerequisites and typical usage context. It fails to mention that this should be called after receiving a callback_query, or that it is necessary to prevent UI spinning. The description is incomplete for an agent to understand when and why to invoke it.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining 'toast text / alert', which maps to the 'text' and 'show_alert' parameters, giving agents a hint about their purpose. However, it does not clarify the distinction between toast and alert (i.e., show_alert=true forces a popup), nor does it explain the required callback_query_id beyond its obvious name.

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

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

The description clearly states the action: acknowledging a callback_query, which is a specific verb and resource. It also hints at optional parameters (toast text/alert). However, it does not explicitly differentiate from sibling tools like telegram_send_message or telegram_edit_reply_markup, though the resource is distinct enough to infer.

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

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

No guidance on when to use this tool versus alternatives. It does not mention that this is typically called in response to a callback_query from the user, nor does it state any conditions or exclusions. The description provides no context for selection.

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

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

No annotations are provided, so the description carries the responsibility for behavioral disclosure. It does explicitly disclose that null/omitted buttons strip markup, which is a destructive action, and that the target must be an existing message. However, it does not mention side effects on message content, permission requirements, or the separate clear parameter's 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 two concise sentences with no fluff. The core action is front-loaded, and the parameter guidance follows naturally 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?

The description covers the primary use case well and benefits from an output schema, but it leaves material gaps: the clear flag and row_width are undocumented, and there are no notes about constraints or failure modes. For a mutation tool with zero annotations, a bit more context would be needed for fully confident invocation.

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

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

Schema description coverage is 0%, and the description compensates partially by explaining the buttons parameter's two modes: null/omit to clear and a [{id,label}] list to set. However, it does not explain the clear boolean or row_width parameter, which are both non-obvious and absent from the 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 a specific verb ('Edit or clear') and resource ('inline buttons on an existing message'), making the tool's purpose immediately clear. It also distinguishes this tool from sibling tools like telegram_send_message and telegram_get_updates by focusing on modifying an existing message's markup.

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

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

The description gives clear operational guidance: pass buttons=null/omit to strip markup, or provide a new list to set buttons. It does not name sibling alternatives or explicitly state when not to use the tool, but the context of editing an existing message is sufficiently clear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says the operation fetches metadata and offers no context about read-only behavior, authentication requirements, failure modes, or what happens if the chat_id is invalid or inaccessible.

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 and no redundant information. Every word contributes to the meaning, which is ideal for a simple one-parameter tool.

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

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

With a simple one-parameter schema and an output schema present, the description covers the core mechanics. However, the absence of annotations and usage guidance leaves gaps around when to call it and what behavioral expectations exist, making it only minimally adequate overall.

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

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

Schema description coverage is 0%, so the description must compensate, but it merely repeats the chat_id parameter name without explaining accepted formats, constraints, or meaning. It adds little beyond the input schema itself.

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

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

The description uses a specific verb ('Fetch'), a clear resource ('chat metadata'), and names the underlying API ('getChat'). It clearly conveys the tool's purpose, though it does not explicitly differentiate it from siblings like telegram_get_me or telegram_get_updates.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any exclusions or preferred contexts. An agent must infer the intended use solely from the tool name and the word 'metadata'.

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

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

With no annotations, the description carries the burden, and it does convey the read-only behavior by saying 'Return' and framing the call as a check. It adds the useful operational context of connectivity verification, though it does not discuss auth or error behavior, which is acceptable for this simple tool.

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

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

The description is two short sentences with no filler. The core action and resource are stated first, and the diagnostic use case is added in a single appended clause.

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

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

For a zero-argument, read-only endpoint with an output schema available, the description is complete. It tells the agent what the tool returns and when to use it, and nothing else is needed to invoke it correctly.

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

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

The tool has zero parameters and the schema confirms this, so there are no parameter semantics to clarify. The baseline score of 4 applies because the description has nothing meaningful to add 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 names the specific verb 'Return' and the resource 'bot identity', and explicitly references the getMe API. This clearly distinguishes it from sibling tools like telegram_get_chat or telegram_send_message, which act on different resources.

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

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

The description explicitly frames the tool as useful for a connectivity check, which is clear usage context. It does not name exclusions or alternatives, but for a zero-argument diagnostic method this is sufficient guidance.

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

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

With no annotations, the description takes on the disclosure burden and does it well: it reveals long-polling, agent-managed offsets, and the conditional safety classification output. It stops short of a 5 by omitting things like rate limits, webhook conflicts, or error behavior.

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

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

Two dense sentences front-load the core operation and then add the two most important behavioral details: offset-loop ownership and the SAFETY_STRICT behavior. No filler, no redundancy.

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

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

The output schema covers the return shape and the description covers key behavior, so the agent is not entirely lost. But for a tool with three parameters and 0% schema coverage, the lack of limit/timeout semantics and any prerequisites makes it incomplete for fully 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 only meaningfully explains the offset concept via 'agent owns the offset loop.' Limit and timeout are left completely unexplained, so it only partially compensates for the schema's 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 states a specific verb and resource ('Long-poll getUpdates') and conveys the core nature of the operation. This clearly separates it from siblings like get_me, get_chat, and send_message, which serve obviously 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?

It provides operational context by telling the agent it owns the offset loop and by explaining the SAFETY_STRICT conditional behavior. However, it does not explicitly state when to choose this tool over alternatives or when not to use it, leaving selection guidance mostly 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?

With no annotations to carry safety or side-effect information, the description discloses two meaningful behaviors: outbound text is scrubbed for token-shaped secrets, and optional buttons become an inline keyboard. It does not cover all possible behaviors (e.g., parse_mode side effects), but it adds real value beyond a bare 'send message' statement.

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

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

Two short sentences with the main action front-loaded and no filler. The token-scrubbing warning and button behavior each earn their 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 has five parameters, no annotations, and no schema description coverage, so the description carries a heavy load. It covers the core action and a critical gotcha (secret scrubbing), but omits semantics for parse_mode and row_width, which an agent would need to format messages or arrange buttons correctly.

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

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

Schema description coverage is 0%, so the description must explain parameters. It only clarifies that optional buttons=[{id,label}] produce an inline keyboard, leaving chat_id, text, row_width, and parse_mode unexplained beyond their schema names and types.

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

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

Opens with a specific verb and resource: 'Send a text message.' This clearly distinguishes it from sibling tools like telegram_get_me and telegram_get_updates, which are read/polling operations, and from telegram_edit_reply_markup, which modifies existing messages rather than creating a new one.

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

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

The description makes the core use case clear—sending a message—and implies it should be used whenever the agent needs to post text to a chat. However, it provides no explicit guidance on when not to use it or how it differs from siblings such as telegram_answer_callback or telegram_edit_reply_markup.

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