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

With no annotations, the description carries the transparency burden. It conveys read-only intent ('Read') and scope ('bounded', 'exactly one stable message anchor'), but omits details about error handling, pagination, or authentication. This provides some value but leaves significant gaps.

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 with no redundant words. It front-loads the verb and clearly states the core purpose, making it concise and easy to scan.

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

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

Despite an output schema, the tool has 7 parameters and no helpful annotations. The description only offers a high-level purpose, lacking the context needed to know when to use it, how to set the anchor, or what the counts mean. This is insufficient for correct selection and 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 map any parameter to concepts like 'anchor' or 'bounded context'. Terms like after_count and before_count are left unexplained. The description adds minimal compensation for the missing 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 clearly states the action ('Read') and the specific resource ('bounded context around exactly one stable message anchor'). It differentiates from siblings like read_chat_range or read_chat_day by emphasizing a single anchor, though it does not explicitly name alternatives.

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

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

There is no guidance on when to use this tool versus the many sibling tools. It does not mention prerequisites, alternatives, or any exclusions. The context is implied but not explicitly described.

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

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

With no annotations, the description carries the transparency burden. It discloses that the tool scans stable 200-message pages and does not return bodies, which is useful. However, it omits important behavioral details such as the max_messages cap and potential truncation of counts, limiting full 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 a single, front-loaded sentence with no filler words, earning every character. However, the term 'stable' is jargon and could confuse agents, slightly reducing clarity.

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 five optional parameters and an output schema, the description is far too brief. It fails to explain parameter meanings, the max_messages limit, and when to use this tool versus siblings, leaving significant gaps in context 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?

The schema description coverage is 0%, and the description does not explain any of the five parameters (chat, period, talker, timezone, max_messages). 'Bounded period' only vaguely references the period parameter, leaving all other parameters semantically unexplained.

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

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

The description clearly states the tool 'Count a bounded period without returning bodies', using a specific verb and resource, and distinguishes it from reading tools. It clarifies the scope (bounded period) and the key behavior (no bodies), which differentiates it from siblings like read_chat_range.

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 used when only a message count is needed, but it does not explicitly state when to use it over alternatives or mention any exclusions. There is no naming of sibling tools or comparison to similar functions, leaving usage context vague.

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 adds a useful constraint ('explicit MEDIA and FILE_TEXT opt-in required') and specifies file types, but it does not clarify whether the operation is read-only, what side effects may occur, or how the opt-in is actually performed. This leaves significant behavioral ambiguity despite some added value.

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 two clauses, front-loading the core action and then adding the key opt-in constraint. Every word earns its place; there is no redundancy or 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?

The description covers the basic action and file types, but it lacks usage context, parameter explanations, and details about the opt-in mechanism. The presence of an output schema helps with return values, but the tool remains under-documented given its sibling family and specific requirements, leaving the agent with too many unanswered questions about how and when to invoke it.

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

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

Schema description coverage is 0%, and the description does not explain any of the four parameters. The parameter names (chat, local_id, server_id_str, max_chars_per_file) provide some clues, but the distinction between local_id and server_id_str is unclear, and the description adds no semantic value beyond the schema's basic types and defaults.

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 ('Extract text') and the resource ('local txt/PDF/Office files'), with a specific scope that distinguishes it from siblings like message_media, ocr_message_images, and transcribe_message_voice. This is a specific verb+resource combination with file-type 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 implies usage through file types and the opt-in requirement, but it does not explicitly say when to use this tool versus alternatives such as ocr_message_images or transcribe_message_voice. No exclusions or alternative comparisons are provided, so the agent must infer suitability from the brief mention of 'txt/PDF/Office files'.

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 discloses that a network opt-in is required, which is a meaningful behavioral trait beyond the basic purpose. However, it is ambiguous whether the tool merely extracts URLs from the message or actually accesses them, and no side effects or auth requirements are mentioned. With no annotations, more behavioral context is needed.

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 conveys the core purpose and a key constraint in eight words, 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?

Despite having an output schema, the tool has four parameters with no explanations, and the identification mechanism (via chat plus local_id/server_id_str) is undocumented. The network behavior is also ambiguous. This leaves significant gaps 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?

The schema provides no descriptions for any of the four parameters (chat, local_id, server_id_str, max_chars_per_link), and the description does not compensate. There is zero schema coverage, so the agent cannot determine how to specify the target message or the meaning of max_chars_per_link.

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 fetches public HTTPS links from a single message, using the specific verb 'fetch' and resource 'links'. This distinguishes it from sibling tools like message_media or extract_message_files.

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

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

The description gives no guidance on when to use this tool versus alternatives. It only mentions an 'explicit NETWORK opt-in required' constraint, which is a precondition rather than usage context. No exclusions or alternative tool names 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 no annotations, the description carries the full burden of behavioral disclosure. It only states the core action, without mentioning pagination behavior, whether stats are included via include_stats, or any constraints/requirements. No side effects or return characteristics are 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 a single, front-loaded sentence with no redundant words. It efficiently conveys the tool's main purpose without fluff, though this brevity contributes to the lack of parameter coverage.

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 having an output schema, the description is minimal: it omits explanation of the meaning of limit/offset/include_stats and does not elaborate on the 'resolved' prerequisite. For a tool with four parameters and zero schema descriptions, the description is insufficiently complete to guide 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 mentions none of the parameters (chat, limit, offset, include_stats). The description does not compensate for the lack of parameter documentation, relying entirely on the bare parameter names 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 ('List') and explicitly states the resource ('group members and group nicknames') for a resolved group chat. This clearly differentiates it from sibling tools like read_chat_range or timeline, which focus on messages rather than membership.

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 'for a resolved group chat' implies a prerequisite to use resolve_chat first, but does not explicitly state when to use this tool vs alternatives or provide any exclusions. The usage context is implied rather than explicitly guided.

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

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

With no annotations, the description carries the full burden of disclosing behavioral traits. It adds context about returning safe structures and excluding debug secrets, which is helpful, but it does not state whether the operation is read-only, the required permissions, or any side effects. This leaves the agent uncertain about the tool's safety profile.

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 core purpose ('Expand one message') and includes only relevant detail ('safe quote/forward/link/file structures without debug secrets'). Every word earns its place, making it highly efficient.

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

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

While an output schema is present, the description leaves significant ambiguity around how to specify the message and how the parameters relate. The 0% schema coverage and lack of parameter guidance make it incomplete for an agent to confidently invoke the tool, especially without knowing whether local_id or server_id_str (or both) are required.

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 explanation of the three parameters (chat, local_id, server_id_str). It does not clarify how to identify a specific message, whether local_id and server_id_str are alternatives, or that chat is required. The description fails to compensate for the schema gap.

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

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

The description uses the specific verb 'expand' and clearly identifies the resource as 'one message'. It further distinguishes the tool from siblings by mentioning safe quote/forward/link/file structures, which implies a detailed message view rather than a timeline or media-specific 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?

Usage is implied from the phrase 'one message' – it is for when you need details of a single message. However, there is no explicit guidance on when to use this versus alternatives like timeline or read_chat_range, nor any exclusions or prerequisites. The description lacks a clear 'when 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?

With no annotations, the description must carry the full burden of behavioral disclosure. It conveys a read-only intent ('locate') and the environment variable requirement, but it does not disclose what happens when media is missing, whether permissions are needed, or how the 'allow_derived_write' parameter affects behavior (implying potential writes). The write-capable parameter is a notable omission for 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 a single concise sentence with no wasted words. It front-loads the core purpose and includes a key prerequisite, making it highly efficient for an agent to parse.

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

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

The tool has 4 parameters, no annotation support, and zero schema descriptions, so the description must provide substantial context. It only specifies the core function and a prerequisite, but omits how to choose between local_id and server_id_str, the meaning of 'chat', and behavior around derived writes. Although an output schema exists, the input side and usage context remain severely under-specified.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It provides no details about 'chat', 'local_id', 'server_id_str', or 'allow_derived_write'. The parameter titles in the schema are minimal, and the description does not clarify their roles (e.g., how to specify a message vs a chat, or the implications of derived writes). This leaves the agent guessing.

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 function with a specific verb ('locate') and resource ('existing local message media paths'), which clearly conveys its purpose. However, it does not explicitly differentiate from sibling media tools like extract_message_files or ocr_message_images, so it misses the top score.

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 only usage guidance is the prerequisite 'requires WECHAT_MCP_ENABLE_MEDIA=1', which is a condition rather than guidance on when to use this tool versus alternatives. There is no mention of when-not to use it, nor any reference to sibling tools, leaving the agent without clear selection 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 no annotations, the description carries full behavioral disclosure. It mentions using macOS Vision and the opt-in requirement, but fails to disclose any side effects, output behavior, or the significance of the 'allow_derived_write' parameter. The description does not mention whether the tool can write data, which is a critical behavior given the parameter.

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 fluff, and it front-loads the core purpose. However, it is so brief that it omits essential parameter and usage context, which slightly reduces efficiency. Every word earns its place, but more detail would improve overall usefulness.

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 descriptions, yet the description provides only a one-line summary. It lacks essential context about parameter meaning, side effects (especially 'allow_derived_write'), output formatting, and when this tool is preferred over siblings. For a moderately complex tool, this is insufficient.

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

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

Schema description coverage is 0%, and the description itself provides no explanation of the five parameters. It does not clarify what 'chat', 'local_id', 'server_id_str', 'languages', or 'allow_derived_write' mean. The agent would have no guidance on how to populate these parameters beyond their 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 clearly states the tool performs OCR on readable local images using macOS Vision, which is a specific action and resource. It does not explicitly differentiate from sibling tools like transcribe_message_voice or message_media, but the OCR function is distinct enough. The mention of opt-in requirements adds 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 implies when to use the tool (when you need OCR on local images) and provides a clear prerequisite ('explicit MEDIA and OCR opt-in required'). However, it does not provide alternatives or exclusions, such as 'use extract_message_files for non-OCR tasks' or 'not for remote images'. The guidance is contextually clear but lacks explicit comparison to 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 carries the full burden. It discloses pagination behavior (one page, next_cursor loop, data.page.done), which is useful. However, it does not reveal other behavioral traits such as timezone semantics, filtering by talker, or the effect of 'compact'. The pagination disclosure is a positive but incomplete 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 very concise—two sentences with no filler. The key action is front-loaded ('Read one page...'), and the pagination instruction is direct. 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?

For a tool with 8 optional parameters, no annotations, and an output schema, the description is too sparse. It gives a useful pagination pattern but omits essential context about parameter semantics, period calculation, filtering, and response shape. The output schema may cover return values, but the description still fails to equip the agent with enough decision-making information.

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 for 8 undocumented parameters. It only hints at 'day/natural period' (relating to period) and 'one page' (relating to limit/cursor), but does not explain chat, talker, compact, timezone, or include_summary_template. The description adds minimal meaning beyond the raw schema default 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 states a specific action: 'Read one page for a day/natural period', with the resource implied by the tool name (chat). It distinguishes from siblings like read_chat_range by emphasizing 'one page' and 'day/natural period' rather than a range or multiple chats. However, it does not explicitly name the resource (messages) or fully clarify the 'natural period' concept.

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 a clear usage instruction: 'loop with next_cursor until data.page.done.' This tells the caller how to paginate. However, it does not explain when to use this tool versus alternatives like read_chat_range or read_multiple_chats_day, and lacks any exclusion 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?

No annotations exist, so the description carries the burden. It discloses a stable page guarantee and the need to reuse next_cursor for subsequent pages, but it does not explain ordering, filtering, or how parameters like limit and compact affect behavior.

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

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

A single sentence of 13 words, front-loaded with the action, no filler. Every word earns its place and the structure is immediately scannable.

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 8 parameters, no annotations, and 0% schema coverage, the description is too sparse. It captures the core pagination concept but leaves most parameter semantics and behavioral details unaddressed. The output schema helps but does not compensate for the missing parameter explanations.

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 clarifies after/before as a range and hints at cursor reuse. It leaves limit, compact, timezone, chat, and talker unexplained, providing minimal value for most of the 8 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 reads a stable page of chat messages within an explicit [after,before) range. It distinguishes itself from day-based tools like read_chat_day and timeline by emphasizing range-based pagination and cursor reuse.

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 clear context: use this tool for a stable page in a defined range, with next_cursor for pagination. However, it does not explicitly compare with sibling tools or state when not to use it, 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?

With no annotations provided, the description carries the disclosure burden. It clearly communicates that the operation is a read, does not auto-follow loops, does not send messages, and does not control UI. These are non-obvious behavioral traits beyond what the tool name alone conveys. It doesn't cover rate limits or return semantics, but the output schema provides structural details, and the description effectively sets behavioral boundaries.

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 leads with the primary action and resource, then adds critical behavioral exclusions. It is wholly efficient, with no wasted words; every clause earns its place.

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

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

Although the description establishes the tool's core purpose well, it is incomplete for effective use: none of the 6 parameters are explained, and the lack of any parameter semantics makes it difficult to craft correct calls in the face of 0% schema coverage. There is no guidance on how to construct a batch (e.g., using cursor) or how output relates to parameters. The output schema exists but doesn't mitigate the missing parameter 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 6 parameters with zero description coverage, and the description provides no information about what any parameter means. There is no mention of 'chat', 'limit', 'cursor', 'talker', 'since_time', or 'since_local_id'. With 0% schema coverage and no compensating detail in the description, an agent cannot infer parameter semantics from this description 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 clearly states a specific action: 'Read one incremental event batch'. It identifies the resource (event batch) and modality (incremental, one batch), distinguishing it from siblings like timeline or read_chat_range. The explicit exclusion of 'no follow loop, sending, or UI control' further demarcates its scope.

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

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

The description provides clear usage context: it reads a single incremental batch and explicitly disclaims follow-loop, sending, and UI control behaviors. This tells the agent when to use it (single batch read) and, by exclusion, when not to use it (when following a loop or sending messages is needed). It doesn't name specific alternative tools, but the exclusions are strong guidance.

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

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

With no annotations, the description carries the burden of disclosing behavior. It usefully reveals that only one page per chat is read and that cursors enable continuation, which is key behavioral context. However, it omits any mention of side effects, error handling, or limits beyond pagination, so the disclosure is partial.

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 immediately states the core action and the pagination mechanism, making it as concise as possible while still being informative.

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

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

Although an output schema exists (so return values need not be detailed), the description remains insufficient for a complex multi-parameter tool. It does not explain how to set up the 'cursor_by_chat' structure, how 'compact' affects output, or how timezone influences day boundaries. This lack of contextual guidance could lead to incorrect 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?

The schema has zero description coverage, so the description must compensate. It explains the purpose of 'chats' (multiple), 'period' (same day), and 'cursor_by_chat' (returned cursors), but it does not explain 'compact', 'timezone', or 'per_chat_limit'. These parameters remain semantically opaque, leaving a significant gap 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 action ('Read') and the resource ('one page per chat for the same day'), and the tool name 'read_multiple_chats_day' explicitly distinguishes it from siblings like 'read_chat_day' (single chat) and 'read_chat_range' (range-based). The scope is precise 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?

The description implies usage: you would use this tool when needing to read multiple chats for a single day, with pagination across chats. However, it does not explicitly mention when not to use it or name alternatives (e.g., 'read_chat_day' for a single chat), leaving the usage context merely implied rather than directly 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, the description carries the burden of explaining behavior. It does not disclose whether the resolution is exact, case-insensitive, returns multiple matches, requires specific permissions, or any side effects. The mention of 'stable talker' hints at a mapping concept but lacks detail.

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, extremely compact. It front-loads the primary purpose and includes a practical suggestion, but the brevity leaves significant gaps in semantics and usage context.

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

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

For a tool with no annotations, 3 params, and 0% schema coverage, this description is insufficient. It lacks details on return behavior, ambiguity handling, and parameter options. The presence of an output schema mitigates some gaps, but the description still fails to provide complete 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 coverage is 0%, so the description must compensate. It explains that 'query' is a display name and that 'type_filter' can be 'group', but it does not explain 'limit' or the meaning of other type_filter values. The coverage is partial and leaves key parameters ambiguous.

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

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

The description clearly states a specific action: resolving a display name to a stable talker. It distinguishes itself from the sibling read/send tools by focusing on name resolution, though it does not explicitly contrast with alternatives like 'search'.

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 only usage hint is 'prefer type_filter=group when applicable', which is more about parameter selection than tool selection. There is no guidance on when to use this tool versus siblings, nor any exclusions or prerequisites.

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 itself. It adds 'half-open time range' which explains after/before semantics, but omits other behavioral traits like pagination via limit/offset, snippet_only behavior, or text truncation (max_text_chars). 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?

One sentence with no waste. It effectively front-loads the primary action and key filters.

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 complex tool with 11 params and no annotations, the description is too sparse. It doesn't mention pagination, snippet behavior, or the meaning of talker, and lacks usage context versus siblings. The output schema exists but the description still needs to cover more ground.

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 has 0% description coverage for properties. Description clarifies only chat, sender, type, and half-open time range (after/before), but leaves other parameters like talker, snippet_only, max_text_chars, limit, offset unexplained. It provides some semantic value but not enough for an 11-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 searches local messages and lists optional filters (chat, sender, type, time range). It distinguishes from siblings like read_chat_range by implying keyword-based search, though it doesn't explicitly mention the required 'keyword' 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?

No guidance on when to use search vs alternatives like read_chat_range, timeline, or count_messages. It implies usage via the verb 'search' but provides no exclusions or alternative tool references. Given the many sibling tools, this is a significant gap.

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

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

With no annotations, the description must disclose behavioral traits. 'List sessions' implies a read operation but doesn't explicitly state it, and there is no mention of pagination, rate limits, authentication, or data scoping beyond the filter hint.

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 immediately state the action and provide a practical tip. There is zero filler, and every word contributes to understanding the tool.

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

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

The tool has four optional parameters and no annotations, yet the description is minimal. It does not define what a 'session' is, how results are ordered, or how this tool relates to the many sibling tools. The output schema exists, but the contextual role is under-described.

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

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

Schema description coverage is 0%, so the description needs to compensate. It adds meaningful context for type_filter ('group for group-chat workflows') but leaves limit, offset, and keyword entirely unexplained beyond their schema names and defaults.

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 'List sessions' states a specific verb and resource, clearly indicating the tool's function. The added phrase 'use type_filter=group for group-chat workflows' gives a targeted use case, but it does not explicitly distinguish from sibling tools beyond the resource type.

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 hint to use type_filter=group for group-chat workflows provides a conditional usage guide. However, it does not explain when to use this tool over alternatives like timeline or resolve_chat, nor does it mention any exclusions.

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

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

With no annotations, the description carries the full burden. It mentions 'without identity paths' as a scoping hint but does not disclose whether the tool is read-only, rate-limited, or what the response contains. The behavioral profile is largely undisclosed.

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

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

A single, front-loaded sentence with no filler. Every word adds value, and the structure is efficient.

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

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

The tool is simple (0 parameters) and has an output schema, so the description need not explain returns. However, the phrase 'live-read readiness and opt-in enrichment capabilities' is jargon and may leave an agent uncertain about when to invoke this tool. More context about the underlying system 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?

The tool has zero parameters, so the baseline is 4. The description adds meaningful context about what the status check covers, which helps an agent understand the purpose even though no parameters exist to clarify.

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 ('check') and names a resource ('live-read readiness and opt-in enrichment capabilities'). It conveys a distinct purpose but does not clearly distinguish from sibling tools like 'unread' or '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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention exclusions, prerequisites, or scenarios where this tool is preferred over 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It does disclose that the tool returns a single bounded page and requires cursor-based looping, which is valuable. It does not mention read-only nature, side effects, or error behavior, but the verb 'Read' implies a safe read operation, providing a baseline level of transparency.

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

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

The description is a single sentence that front-loads the core action ('Read one bounded timeline page') and immediately follows with the essential loop instruction. Every word earns its place, and there is 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?

Although an output schema exists, the tool has 14 optional parameters and no parameter descriptions. The description only covers the pagination loop and does not explain what filters (chat, sender, keyword, message_type, etc.) do, how ordering works, or how the cursor interacts with before/after parameters. For a tool this complex, the description is far from complete.

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

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

Schema description coverage is 0%, and the description adds no explanation for any of the 14 parameters. The only mention is of the response field 'data.page.next_cursor', not input parameters. With no parameter semantics provided, an agent would have to infer the meaning of fields like 'after_message', 'display_order', or 'compact' from names alone, which 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 uses the specific verb 'Read' on the resource 'bounded timeline page' and explicitly mentions the pagination pattern, clearly distinguishing it from sibling read tools that likely fetch ranges, days, or events. The scope is precise: one page at a time, loop until done.

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 usage instruction to loop with data.page.next_cursor until done, which is strong contextual guidance for iterative pagination. However, it does not explicitly name alternatives (e.g., read_chat_range) or say when not to use this tool, so it earns a 4 rather than 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?

No annotations are present, so the description must carry the full burden of behavioral disclosure. It reveals that the transcriber is user-configured and invoked via argv, which is useful. However, it omits side effects (e.g., allow_derived_write parameter suggests potential writes), error behavior, or any prerequisites like file availability.

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 immediately states the action, resource, and method. It contains no filler or redundant information, making it highly efficient 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?

Given 4 parameters, no annotations, and an output schema, the description is too sparse. It does not explain how to identify the voice file (local_id/server_id_str), the role of 'chat', or what 'allow_derived_write' means. The agent would struggle to correctly invoke the tool despite the 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 mention any parameter. The schema provides only titles and defaults, leaving 'chat', 'local_id', 'server_id_str', and 'allow_derived_write' ambiguous. This is a severe gap for a 4-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: 'Transcribe a local voice file' using a specific method ('user-configured argv-only local transcriber'). It is unambiguous and distinct from all sibling tools, which focus on chat reading, search, and media handling.

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 this tool: whenever a local voice file needs transcription. However, it does not explicitly mention alternatives or exclusions, though siblings are unrelated and no alternative transcription tool exists. This provides clear context without explicit 'when not to use' guidance.

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

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

There are no annotations, so the description must carry the full burden for behavioral disclosure. It reveals the tool's purpose but does not disclose any side effects, authentication requirements, rate limits, or the runtime behavior of fetching unread sessions. The only added context is the optional filter on chat types, which is minimal for a tool with no 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 front-loaded with the core action ('List unread sessions') and adds only the key optional constraint. There is no redundant information, making it highly efficient 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?

For a simple list operation with an output schema and no required parameters, the description covers the essential purpose but lacks details on pagination parameters and possible side effects. However, given the output schema exists and the tool is straightforward, it is minimally viable. The sibling context is not addressed, but the description is sufficient for basic 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 schema has 0% coverage, so the description must compensate. It partially explains the 'type_filter' parameter by mentioning restriction to group/private chats, but 'limit' and 'offset' are not addressed. Since pagination is a common concern, the description's failure to explain these leaves 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 the specific verb 'List' with the resource 'unread sessions', clearly defining its scope. It also mentions an optional restriction to group/private chats, which distinguishes it from the sibling tool 'sessions' that likely lists all sessions. This satisfies the criteria for differentiating from siblings.

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

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

The description implies usage when you need a list of unread sessions, and the optional restriction hints at filtering scenarios. However, it does not explicitly state when to use this tool over alternatives like 'sessions' or 'read_chat_range', nor does it mention exclusions. This is implied usage rather than explicit guidance.

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