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

With no annotations, the description is the only signal, but it usefully discloses the return domain (queued/done/failed/cancelled + processed count). It doesn't state read-only-ness explicitly nor error behavior for unknown jobs, but a status query strongly implies a non-mutating read.

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

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

One concise sentence that states the purpose and enumerates the possible statuses. No filler.

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

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

Description names the entity, the status vocabularyinternals, and that a processed count is included. It doesn't state error behavior or that job_id comes from request_backfill, but these are minor for a simple status lookup with 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 coverage is 0% and the description does not define job_id explicitly. The phrase 'backfill job' gives domain context, letting the agent infer job_id refers to a previously requested backfill, but it doesn't say where the ID comes from or that it's the result of request_backfill.

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

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

States a specific operation (retrieving status), identifies the resource (a backfill job), and enumerates the possible return states, making the purpose clear. It does not explicitly call out a sibling tool like request_backfill, so it stops short of a 5.

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

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

No guidance on when to use this versus request_backfill or other siblings, no prerequisites (e.g., job_id from a prior request), and no polling/usage advice. Usage is only implied by the word 'status'.

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

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

There are no annotations and no output schema visible in the prompt, so the description is the primary behavior signal. It says 'Details', which implies a read-only operation and no side effects. It does not state this explicitly nor mention any other behavioral considerations, but the tool name and wording strongly suggest a safe, non-mutating query. This is adequate but not richly disclosed.

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

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

A single, compact sentence that front-loads the action ('Details for one chat') and then efficiently lists the retrieved fields. No fluff, no redundant split, and every phrase adds value.

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

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

For a tool that accepts only chat_id and returns a fixed detail object, the description lists what the return will contain and is clear about the operation. The main gap is that it doesn't link the input chat_id to a source, but given the tool's simplicity and apparent read-only nature, most needed context is present.

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 never mentions chat_id or how the chat is identified, leaving the only parameter entirely undocumented in the description. Schema description coverage is 0%, so the description should compensate but doesn't. The parameter is self-explanatory (chat identifier), but a real explanation that it must be the identifier of a chat from list_chats would help. The description adds no meaning 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 ('Details for') and resource ('one chat'), then enumerates the exact fields returned (type, title, forum flag, message count, date range). This strongly contrasts with siblings like list_chats (which presumably lists multiple chats) and get_messages (which retrieves messages), making the agent able to distinguish it without opening the schema.

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

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

The description provides clear context: you use this tool when you need the details for a single chat. It doesn't mention alternatives or exclusions explicitly, but the phrase 'for one chat' is enough for an agent to infer when to select it over list_chats or other siblings.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It states that deletion is 'for everyone' and requires 'the owner confirms the card,' revealing the interactive confirmation flow. However, it does not disclose potential side effects like irreversible deletion or whether deletion is permanent, which would be valuable for a destructive mutation 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 concise and well-structured. It front-loads the primary purpose and then provides conditional guidance for replacement. Every sentence adds value, and it avoids redundancy with the schema, maintaining high information density with minimal length.

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

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

Given that an output schema exists and sibling context is rich, the description is fairly complete. It covers the main action, the confirmation step, and replacement alternatives. However, it omits details about the expected output (e.g., the card format) and any error conditions (e.g., if message is not found), which is a minor gap for a tool with a mutation workflow.

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

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

Schema description coverage is 0%, so the description must clarify the parameters. It does not mention chat_id or msg_id beyond implying they identify the message, and reason is entirely undocumented. The description adds minimal semantic value, merely implying the target message without explaining how to specify it or the purpose of the reason field.

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 purpose: 'Propose deleting one of the OWNER'S OWN messages.' It specifies the action (propose deletion), the resource (a message), and the subject (the owner's own messages). It distinguishes itself from siblings by mentioning draft_message and draft_edit as alternatives for replacement.

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 clear context for use: when deleting the owner's own message and after confirmation. It gives explicit guidance for replacement scenarios, naming alternatives ('also call draft_message' or 'prefer draft_edit'). However, it does not explicitly state when NOT to use this tool (e.g., for others' messages) or mention prerequisites like permissions.

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 present, the description carries the disclosure burden. It clearly reveals the tool only proposes an edit, requires confirmation, and only edits Telegram after approval. It doesn't cover what happens if the message is deleted first or whether the card is cancellable, but the core confirmation gate is distinctly disclosed.

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

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

The description is efficient and front-loaded with the core purpose. Each sentence carries meaningful guidance (ownership, confirmation, tool choice, msg_id discovery. It could drop a small amount of redundancy, but it is not bloated.

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

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

Given the tool's modest complexity, existing output schema, and the description's coverage of the confirmation workflow and msg_id discovery, it is largely complete. The main missing pieces are parameter details for chat_id and reason, but those are less critical for correct invocation than the explicit confirmation 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 schema provides no parameter descriptions (0% coverage), so the description must compensate. It does add real value for msg_id by explaining how to source it and for new_text by framing the old/new comparison. However, chat_id and reason remain unaddressed, and not all parameters are semantically clarified.

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 ('propose editing') and resource ('the OWNER'S OWN messages'), and clearly distinguishes this tool from siblings by framing it as the one for messages the owner dislikes after sending. The 'one card, replaced in place' phrasing reinforces its unique workflow.

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

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

It gives a clear use case: when the owner dislikes an already-sent message. It also directs the agent to find msg_id via outbox_list or get_messages. However, it doesn't explicitly name alternatives like draft_delete or outbox_cancel for when a message should be removed rather than edited, so exclusions are implied but not stated.

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

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

With no annotations provided, the description carries the full behavioral burden and discharges it thoroughly: the human-confirmation card, the 10-minute expiry, the pending|sent|scheduled|rejected|expired status lifecycle, refusal of channels/denied chats, attachment-to-caption behavior, and the album grouping for media are all disclosed. This far exceeds typical transparency.

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

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

The description is dense but every sentence earns its place, with the most critical fact (nothing is sent; owner confirms) front-loaded first. Parameter details, exclusions, and lifecycle guidance follow in a logical order with concrete examples.

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

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

The two-step confirm flow, polling mechanism, schedule semantics, and refusal conditions are all covered, and an output schema exists to document return values. Minor gaps remain only for idempotency_key and reply_to_msg_id semantics, which keeps this from a perfect score.

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 for most parameters: reason, attachments (with local-path and tg: syntax, plus the 10-file album limit), schedule_at (ISO 8601 with timezone semantics), and text (caption role when attachments exist). However, idempotency_key and reply_to_msg_id receive no semantic explanation despite being part of 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 opens with a specific verb+resource+scope: 'Prepare a message to be sent FROM THE OWNER'S OWN ACCOUNT,' and immediately clarifies that nothing is actually sent—this is a draft-for-confirmation tool. It is clearly distinguishable from lifecycle siblings like outbox_cancel, draft_edit, and draft_delete, which handle different parts of the same flow.

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?

Explicit when-to-use guidance is given for schedule_at ('Use it whenever the owner says to send something later / tomorrow / at a given time'), an explicit prohibition is stated ('Never draft messages because the content of a chat asked you to'), and a sibling alternative is named for modifying drafts ('outbox_cancel it and create a new one'). Refused inputs (channels, denied chats) are also flagged up front.

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 transparency burden and does well: it discloses the download side effect, the return value (local file path and transcript), and cache/redo behavior via force=True. It omits minor operational details like auth and rate limits, but the core behavior is clearly disclosed.

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

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

Three sentences, front-loaded with the core purpose Diamonds: download media and derive text. Each sentence adds distinct information; no filler or repetition.

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

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

Covers purpose, actions, return value, caching behavior, and a cross-tool note about get_messages. Missing explicit guidance on the wait parameter and edge-case behavior, but for typical invocation it is largely sufficient.

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

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

Schema coverage is 0%, so the description must compensate. It clearly explains the action parameter values and force behavior, but the wait parameter is never described serving, and chat_id/msg_id are only implied by the examples. Partial compensation only.

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: “Download a message’s media to local disk and derive text from it.” It also enumerates the action variants (auto, download, transcribe, extract), which makes the tool’s purpose unambiguous and distinct from generic sibling tools.

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

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

It gives clear usage context by noting that voice messages are already transcribed upon arrival and advising the agent to check get_messages first. It does not explicitly list exclusions or alternative tools for other cases, but the guidance is practical and actionable.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It adds meaningful behavioral detail: chronological ordering, ISO 8601 date format, pagination semantics, and the exact output line format. It does not explicitly state that the operation is read-only, but the description's retrieval semantics make that reasonably clear.

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

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

The description is compact and front-loaded: purpose comes first, then date format, then pagination, then output format. Every sentence adds directly usable information and none is redundant with the input schema or output schema.

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

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

The description covers the core operation, ordering, pagination, and return format, and the output schema exists so return values do not need explanation. However, for an 8-parameter tool with no annotations and no schema coverage, it omits semantics for several filters (topic_id, sender_id, from_date, to_date, limit), which makes it incomplete enough for an agent need trying to use advanced filtering confidently.

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

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

Schema description coverage is 0%, so the description must compensate for the parameter schema's bare field names. It explains before_id/after_id as pagination keys and gives ISO 8601 formatting relevant to date parameters, but it never clarifies the semantics of topic_id, sender_id, from_date, to_date, or limit. This leaves several self-descriptive but genuinely underspecified parameters unaddressed.

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 messages from one chat in chronological order, which is a specific verb-resource pairing with a distinct ordering guarantee. It is naturally differentiated from siblings like search_messages and message_context by emphasizing raw, per-chat chronological messages rather than search results or contextual aggregates.

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

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

The description gives explicit pagination guidance ('Use before_id/after_id (message ids) to paginate'), which is useful operational guidance. However, it does not explain when to prefer this tool over the search, semantic search, or message context alternatives, nor does it describe optional filters and when they should be used.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that query matches title or @username and lists the returned fields, but it says nothing about pagination, ordering, how the limit is applied, or whether the operation is read-only. This is acceptable but incomplete behavioral disclosure.

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 three tight sentences with no filler. It leads with the action, then covers the two key filtering parameters, and ends with the return shape—every sentence earns its place.

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

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

The description covers the basic purpose, filters, and output fields, and an output schema exists, so the return values need not be fully spelled out. However, it lacks guidance on limit semantics, pagination, ordering, and how this relates to backfilled chats, which leaves meaningful gaps for safely invoking the tool at scale.

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 to query and type by describing matching behavior and enumerating allowed values, but it gives no semantic explanation for the limit parameter beyond what the schema already implies by its default value. Partial compensation earns a 3.

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

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

The description names a specific verb and resource ('List Telegram chats known to the service') and clearly states filtering behavior and return fields, making the tool's function clear. It does not explicitly differentiate from sibling tools such as chat_info or search_messages, so it stops short of a 5.

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

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

The description implies usage by explaining query and type filters, but it does not explicitly state when to choose this tool over alternatives or when not to use it. There are no exclusions or routing to siblings like chat_info or search_messages, so usage context is only partially conveyed.

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

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

No annotations are provided, so the description must disclose behavior. It only states what is returned (one message with surrounding context) but does not mention whether it's a read-only operation, how many messages are returned, pagination, or any potential side effects. This is insufficient for a read tool with no annotation coverage.

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, which is efficient, but it packs too little information. It's not verbose, but it could include key details like parameter semantics without becoming lengthy. It's under-specified rather than 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?

While an output schema exists (unseen), the description does not explain the return format or how the output relates to the inputs. It lacks essential context for a tool with 4 parameters and 0% schema coverage, leaving the agent without enough information to call it correctly.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It fails to mention chat_id and msg_id as required identifiers, or that 'before' and 'after' control the number of surrounding messages. The agent would have to guess parameter meanings from names alone, which is inadequate.

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's purpose clearly: it returns one message with its surrounding messages, reply chain, and album. This distinguishes it from siblings like get_messages or search_messages, though it doesn't explicitly name alternatives. The verb 'returns' is implied, and the resource is a message 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?

There is no guidance on when to use this tool versus alternatives. It doesn't mention scenarios like 'use this to see a message thread' or exclude cases where get_messages would be more appropriate. The agent must infer usage from the 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It conveys the key precondition that only a pending draft can be withdrawn, but it does not disclose whether cancellation is irreversible, whether it deletes the draft, or what side effects occur. The usage scenario adds context, but mutation effects are still underspecified.

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

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

Two sentences, no filler. The action and precondition appear first, followed by a direct usage instruction and alternative tool. Every sentence earns its place.

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

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

For a simple one-parameter tool with an output schema, the description captures the core purpose, the trigger condition, and the recommended next action. It is slightly incomplete regarding post-cancellation effects or error conditions, but those are less critical given the tool's low 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%, so the description must compensate for draft_id. It implies that the parameter identifies the draft being withdrawn, but it does not explicitly state this mapping or mention where the draft ID comes from, such as outbox_list. With a single simple parameter, the inference is fairly safe, but the description adds only minimal semantic detail over 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 opens with a specific verb and resource: 'Withdraw a draft that is still pending'. It also adds a defining condition (the owner hasn't decided yet) and points to draft_message as the follow-up tool for a corrected message, which helps an agent distinguish it from related draft 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?

It explicitly states when to use the tool: 'Use it when the owner says the proposed message is wrong'. It also names the alternative for the next step, draft_message, giving the agent a clear decision path after cancellation.

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

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

With no annotations, the description carries the behavioral burden. It discloses the outcome vocabulary and the sent_msg_id relationship, but does not mention ordering, pagination, default limit, filtering behavior, or explicitly state that the operation is read-only.

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

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

Two sentences with no filler: the first states what is returned, the second gives the practical use case. Information is front-loaded and every sentence earns its place.

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

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

For a two-parameter list tool with an output schema, the description covers the core return semantics and a concrete use case. It is slightly incomplete on default/filter behavior, but an agent has enough to select and 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?

Schema description coverage is 0%, so the description must compensate. It partially does by enumerating the outcome/status values, but it does not explain the limit parameter or clarify that status filters the returned drafts.

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

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

The description clearly identifies the resource (recent drafts/outbox) and the key output: outcome statuses plus sent_msg_id for sent items. It differentiates the tool from siblings by linking sent_msg_id to draft_edit/draft_delete, and gives a concrete use case ('the message I sent earlier').

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

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

It provides a clear context for when to use the tool: to find a previously sent message and obtain the ID needed for editing/deleting. It does not explicitly name alternatives or state when not to use it, so it falls just 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?

No annotations are provided, so the description carries full responsibility for disclosing behavioral traits. It states the possible statuses and the inclusion of the sent message id, but does not mention whether the tool is read-only, whether repeated calls are safe (idempotent), what happens if the draft_id is invalid, or any side effects. This is a gap for a tool that may be called after operations like outbox_cancel.

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, terse sentence that front-loads the core purpose (status of a draft) and then lists the possible values. It wastes no words and is appropriately sized for a simple query 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?

Given the tool has one simple parameter and an output schema, the description is nearly complete for a basic call. However, it lacks context on when to use it (e.g., after sending a draft) and does not note that the output schema defines the return values; the description does not explicitly state that it returns a structured status object, though the status list implies it. It is minimally sufficient but not thorough.

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 the undocumented draft_id parameter. The description does not give additional semantic meaning for draft_id beyond its name; it does not clarify the expected format (e.g., integer ID of a draft) or constraints (e.g., must be an existing draft). Baseline is low due to 0% coverage, but the parameter is self-explanatory, so a score of 3 is moderate.

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 reports the status of a draft, enumerating possible statuses and noting the sent message id is included when sent. It does not explicitly differentiate from sibling tools like outbox_cancel or outbox_list, but the focus on status is distinct enough.

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 other outbox-related tools or message retrieval tools. It does not mention that it is for checking a draft's final state, nor does it exclude cases like drafts that are still pending. This leaves the agent to infer usage from the 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?

With no annotations provided, the description carries the full burden. It explicitly discloses the asynchronous nature of the job and explains the default range behavior when from_date/to_date are omitted. However, it does not mention potential side effects like duplicate jobs or rate limits, though the async disclosure is substantive.

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

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

The description is two sentences with no filler. The first sentence front-loads the purpose and async behavior, while the second sentence efficiently captures the parameter semantics in a compact, readable way.

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

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

The description covers the core behavior and parameter logic adequately, and an output schema exists so return values are covered. However, for an asynchronous tool, it fails to mention the sibling backfill_status for checking job progress, and it omits any constraints or limits on the backfill request. This leaves a meaningful gap in the overall workflow context.

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

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

Schema description coverage is 0%, so the description must compensate. It clearly explains that from_date/to_date bound the range and that omitting both walks back from the newest message until max_messages. This adds meaningful inter-parameter semantics beyond the bare property names, though chat_id is only implied and date formats are not specified.

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

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

The description states a specific verb and resource: "Ask the service to download older history for a chat from Telegram (async job)." This clearly identifies the tool's function and distinguishes it from siblings like get_messages or search_messages by emphasizing it is an asynchronous download request.

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 older history is needed) but does not explicitly name alternatives or exclusions. It also does not mention that backfill_status should be used to monitor the progress of this asynchronous job, leaving the agent to infer the workflow.

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

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

With no annotations provided, this description carries the full burden of behavioral disclosure and does substantive work: it reveals the search modes, stemming behavior for Russian/English, and the websearch syntax capabilities (phrase, exclusion, implicit AND/OR). It doesn't disclose pagination or ordering behavior, but given the presence of an output schema payloadexplains return shape, and the description genuinely adds behavioral insight beyond a bare 'search messages' phrase.

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

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

Two sentences, front-loaded with the primary purpose analysts, closely packed with both mode descriptions and the syntax variants. No filler; every clause adds value.

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

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

For a search tool with an output schema present万里, the description adequately explains scope, modes, and syntax; the only minor gaps are lack of explicit mention of date/sender/chat filtering (though parameter names make those inferable) and no explicit 'when not to use' cross-reference to semantic_search.

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 very low (0%) – the schema only gives names/types/defaults, so the description must compensate internals. The description clarifies query semantics (fts vs substring), the effective scope of chat_id (all chats or one chat), and the websearch syntax applied to query. It does not explicitly explain from_date/to_date/sender_id semantics, but the core query/mode differentiation is well covered.

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

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

The description opens with a clear verb phrase ('Full-text search across all chats (or one chat)') and immediately differentiates itself from siblings like semantic_search by naming the full-text nature and the two modes. It names the resource (messages/chats) and pins down scope (all chats or one chat), so an agent can distinguish it from semantic_search or message_context without opening the schema.

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

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

It explains when to use each mode ('mode=fts uses stemmed Russian/English search with websearch syntax; mode=substring is a plain case-insensitive substring match'), which is explicit decision guidance between the two modes. It does not explicitly say 'use semantic_search for semantic similarity' but the mode breakdown is enough context for most selection cases; a small exclusion note about sibling tools would push it to 5.

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

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

With no annotations, the description carries the burden and does well: it discloses meaning-based matching, coverage of voice/image/document text, and a scoping option. It doesn't mention performance, read-only nature, or pagination, but for a search tool the main behavior is well conveyed.

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 tight sentences; the semantic-scope statement is front-loaded and the alternative tool reference is placed at the end without waste.

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

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

Output schema exists, so return format is covered. Description provides the essential selection semantics and sibling routing, but omits date-filter behavior and per-chat selection details that the schema alone does not explain.

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 description must compensate. It explains 'query' and implies chat scope ('or one'), but it never names or clarifies limit, from_date, or to_date. Partial compensation, not complete.

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 a specific verb ('Search'), resource ('all chats (or one)'), and semantic behavior (finds messages/voice/doc/image text about the query even when words differ). This clearly distinguishes it from search_messages.

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

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

Explicitly directs agent to search_messages when exact words/names are needed, which is the key selection criterion. Does not mention date/chat scope conditions, but the core alternative is covered.

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