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

Without annotations, the description fully discloses behavior: moves to Trash if permanent=False and Trash folder exists, else permanently deletes. It explains edge cases like localized folder discovery and always-permanent deletion from Trash.

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, using clear bullet-like structure. Every sentence is informative, starting with the main purpose and then detailing behavior variations in an organized manner.

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

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

Given three parameters and no output schema, the description covers behavior, edge cases (Trash, permanent flag), and folder discovery. It could mention return values but remains adequate for an agent to invoke 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?

With 0% schema coverage, the description adds meaning for 'permanent' (default False, effect) and implies 'email_ids' are the messages to delete. However, it does not explicitly describe the 'folder' parameter beyond being the container.

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 deletes multiple messages at once, with specific behavior for permanent vs soft delete. It distinguishes itself from sibling tools like 'delete_email' and 'empty_trash' by focusing on bulk deletion.

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 permanent=True vs False, and the special case of deleting from Trash. It implies appropriate use cases, but does not explicitly state alternatives like 'bulk_move' or 'bulk_set_flags'.

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 behavioral disclosure. It only implies a set operation via 'Star or unstar' but does not explain whether it is a toggle, idempotent, or the impact on other settings. No mention of permissions or limits.

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

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

The description is one short sentence, but it lacks details that would make it more useful. It is not concise in the sense of efficient communication; it is overly terse.

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

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

Given three parameters, zero schema coverage, and no output schema, the description is insufficient. It does not explain the required 'folder' parameter, the format of 'email_ids', or the effect of the 'flagged' boolean.

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 add parameter meaning. It mentions none of the three parameters (folder, email_ids, flagged), leaving their purpose and format entirely 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 stars or unstars multiple emails using the 'Flagged' flag. It distinguishes from siblings like 'mark_flagged' (single email) and 'bulk_set_flags' (general flag setting) by specifying the flag type, though explicit differentiation would be stronger.

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

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

No guidance on when to use this tool versus alternatives such as 'mark_flagged' for single emails or 'bulk_set_flags' for other flags. No mention of prerequisites or context.

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

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

Without annotations, the description carries the full burden. It discloses that it adds the \Seen flag, which is the core behavior, but lacks details on error handling, reversibility, or authorization requirements, leaving gaps for an AI agent.

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 unnecessary words, efficiently communicating the core purpose without overhead.

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

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

The description is too minimal for a bulk operation with no output schema. It does not explain return behavior, partial success handling, or how failures are reported, leaving the agent underinformed.

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

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

The description adds no explanation for the two required parameters (folder and email_ids). With 0% schema description coverage, the agent must rely solely on parameter names, which is insufficient for correct invocation.

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

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

The description clearly states the action (mark as read) and the scope (multiple emails), distinguishing it from siblings like mark_read (singular) and bulk_mark_unread (opposite action).

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

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

The description implies usage for multiple emails but does not explicitly state when to use this tool versus alternatives like bulk_mark_unread or mark_read, nor does it mention any prerequisites or caveats.

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 provided, so the description carries the burden. It discloses the mutational behavior (removes \Seen) but omits any side effects, permission requirements, rate limits, or batch size constraints. Adequate for a simple flag change but not comprehensive.

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

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

Single sentence with no fluff. Every word contributes meaning: verb, resource, action, technical detail. Front-loaded and 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?

As a bulk mutation tool with no annotations or output schema, the description should cover usage bounds (e.g., max email IDs), prerequisites (e.g., folder must exist), and error behavior. None are provided, leaving the agent underinformed.

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 adds no parameter details. It does not explain what 'folder' should be (name, path?), nor the format or semantics of 'email_ids' (e.g., UIDs). No ennumerations or additional 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 clearly states the verb 'mark' and resource 'emails', specifying the action as 'unread' and the technical effect 'removes \Seen'. This distinguishes it from sibling tools like bulk_mark_read or bulk_mark_flagged.

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

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

No guidance on when to use this tool vs alternatives such as bulk_mark_read or mark_unread. The description lacks context for comparative usage.

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

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

Discloses use of a single IMAP session, atomic UID MOVE (RFC 6851) when supported, and fallback to COPY+STORE+EXPUNGE. This adds value beyond the basic purpose, though it does not cover authorization or error handling.

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

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

Two concise sentences, front-loaded with purpose. Each sentence adds necessary technical detail without redundancy.

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

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

Provides core behavioral details (atomic MOVE, fallback, single session) but lacks output format, error handling, or idempotency info. For a bulk operation with no output schema or annotations, more detail is warranted.

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 and no parameter descriptions. The tool description does not add meaning to the three parameters (folder, email_ids, destination). With no param info in schema or description, the agent must infer meaning from names alone.

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

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

Clearly states 'Move multiple messages to another folder in a single IMAP session'. The verb 'move' and resource 'multiple messages' are specific, and the description distinguishes from sibling tool 'move_email' (single move).

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?

Implies usage for bulk moves (e.g., when moving many messages) but does not explicitly state when to use vs alternatives like 'move_email'. No when-not or alternative names 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?

Describes chunked execution, validation behavior, and return of count. No annotations exist, so description carries burden; it covers key behavioral aspects without contradictions.

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?

Very concise: three sentences plus bullet-style arg list. Every sentence adds value, no redundancy.

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

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

Covers all parameters, behavior, and return value. No output schema exists; description explains return count. Could clarify flag format constraints, but references set_flags validation.

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, but description explains all four parameters with examples (e.g., '["\Seen"]'). Compensates well for missing schema descriptions.

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

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

Clearly states 'Set or clear IMAP flags on multiple messages in a single operation,' with a specific verb and resource. Distinguishes from set_flags by noting efficiency and batch processing.

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 compares to looping set_flags and mentions efficiency (~500 UIDs per chunk). Does not give exhaustive when-not-to-use, but provides clear context for batch flag operations.

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

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

No annotations are provided, so the description carries the full burden. It discloses the auto-encoding behavior for names with Cyrillic to IMAP modified UTF-7, which is useful. However, it does not mention error conditions (e.g., duplicate folder name), permission requirements, or side effects.

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

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

The description is two sentences long and contains no filler. Every word adds value: the purpose statement and the encoding clarification.

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 only one parameter, no output schema, and no annotations, the description is reasonably complete. It explains the core action and the key behavioral detail (name encoding). It could mention whether folder creation is idempotent or what happens if the folder already exists, but for a simple creation tool, it is 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 description coverage is 0%, meaning the description must compensate. It adds meaningful context: the name parameter supports human-readable strings including Cyrillic, and will be auto-encoded. This goes beyond the bare schema type definition and helps the agent understand valid inputs.

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

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

The description clearly states 'Create a new mail folder' with a specific verb and resource. It also adds detail about name encoding (Cyrillic, IMAP modified UTF-7), and this action is distinct from sibling tools like rename_folder or delete_folder.

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

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

No guidance on when to use this tool versus alternatives (e.g., rename_folder, bulk_move). There is no mention of prerequisites, conditions for creating folders, or when not to use it.

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

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

No annotations provided, so description carries full burden. Discloses Trash folder discovery, fallback behavior, and possibility of permanent deletion. Lacks mention of permissions or reversibility.

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?

Concise at 5 sentences, front-loaded with purpose, then details. No superfluous information.

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

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

Given 2 parameters, no output schema, and no annotations, description covers deletion behavior, Trash handling, and returns. Could be more complete with permission or side-effect notes.

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 description adds little beyond parameter names; 'folder: Folder containing the email' and 'email_id: Email ID to delete' restate the obvious without additional semantics.

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

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

Clearly states the action 'Delete an email' and resource, with distinction from siblings by specifying move to Trash and fallback to permanent deletion.

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

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

Provides context about Trash folder discovery and behavior, but does not explicitly state when to use this tool versus bulk_delete or other alternatives.

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

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

No annotations are provided, so the description carries full responsibility. It explicitly warns that deletion is destructive, describes server-dependent behavior on non-empty folders with RFC reference, and recommends user approval via the MCP client.

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 with two focused sentences and a warning block. Every sentence adds unique value: the action, the destructive nature, server dependency, and a user approval recommendation.

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 key behavioral aspects like destructiveness and server dependency, which is good for a simple tool with no output schema. However, the lack of parameter documentation limits its completeness for an agent needing to format the folder identifier.

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

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

The input schema has a single required 'name' parameter with no description. The description does not clarify whether this is a folder name, path, or ID, leaving ambiguity despite 0% schema coverage.

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

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

The description clearly states 'Delete a mail folder,' which is a specific verb+resource combination. It is distinct from sibling tools like delete_email or bulk_delete, which target emails rather than folders.

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

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

The description provides a warning about destructiveness and server-dependent behavior, implying caution. However, it does not explicitly contrast with other tools like empty_trash or rename_folder, nor does it specify when to use or not use this tool.

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

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

No annotations are provided, so the description must bear the burden. It discloses that the tool downloads to disk and returns file path and size, but does not mention overwriting behavior, directory creation, authentication needs, or rate limits. Some behavioral context is provided via default save directory, but gaps remain.

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, with a clear first sentence stating the tool's purpose, followed by an Args list and a Returns line. Every sentence adds value, 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?

For a tool with 4 parameters and no output schema, the description covers the core functionality, inputs, and output. It could mention error handling or required prior authentication, but given the context of sibling email tools, it is reasonably complete.

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

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

Despite 0% schema description coverage, the description explicitly explains each parameter's meaning and source (e.g., 'Email ID from search_emails() result', 'Attachment filename to download (from read_email attachments list)'). It also documents the default for save_dir. This fully compensates for the lack of schema descriptions.

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

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

The description clearly states the action (Download) and the resource (an email attachment to disk). It is specific and distinct from sibling tools like fetch_part, which might involve fetching but not saving to disk.

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 prerequisites by referencing 'search_emails()' and 'read_email', but does not explicitly state when to use this tool over alternatives or when not to use it. No exclusions or alternative tool recommendations are provided.

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

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

The description discloses the full sequence of operations (discover Trash, select it, mark deleted, expunge) and the return value (count of deleted messages). Without annotations, this provides good transparency. It does not mention idempotency or behavior when Trash is empty, but the core behavior is 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 three sentences: the first states the purpose, the second explains the mechanism, and the third details the return value. Every sentence adds value, no fluff, and front-loaded with the core action.

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, no-parameter tool, the description covers what the tool does, how it works, and what it returns. Given the absence of annotations and output schema, this is complete and sufficient for an agent to understand and invoke the tool correctly.

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

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

The tool has no parameters (0 params, 100% schema coverage), so the description does not need to add parameter-level details. The baseline for zero-parameter tools is 4, and the description correctly does not waste space on non-existent parameters.

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

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

The description uses a clear verb ('Empty') and specific resource ('the Trash folder'). It explains the discovery mechanism (\Trash SPECIAL-USE) and actions (mark +FLAGS \Deleted, EXPUNGE), which distinguishes it from siblings like delete_folder (which removes a folder) or bulk_delete (which targets arbitrary messages).

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

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

The description implies usage for emptying the Trash folder but does not explicitly state when to use this tool versus alternatives (e.g., 'use this to clean up all trashed messages; for deleting specific messages in other folders, use bulk_delete'). No exclusions or prerequisites are mentioned.

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

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

With no annotations provided, the description fully discloses behavior: how decode affects text vs binary parts, default behavior (decode=True returns decoded string), and fallback to base64 for binary or decode=False. It also explains the return format, making the tool's behavior predictable.

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 well-structured with a concise introductory sentence followed by a clear explanation of part numbers and return behavior, then a bullet-like Args list. It's informative without being verbose, though the Args section could be slightly more compact.

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 complexity (4 parameters, no output schema), the description covers all necessary aspects: input parameters, behavior for different cases, return value structure, and dependency on inspect_email. It is self-contained and complete for an agent to use 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 coverage is 0%, so the description must explain parameters. It does so comprehensively with an Args section detailing folder, email_id, part_number, and decode, including default values and data type implications (str vs base64). This adds significant meaning beyond the bare schema.

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

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

The description clearly states the tool fetches a specific MIME part of an email by part number, using a specific verb ('Fetch') and resource ('MIME part'). It references inspect_email for context, distinguishing it from sibling tools that deal with bulk operations or other email actions.

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 explains that part numbers come from inspect_email's parts list, providing clear usage context. While it doesn't explicitly say when not to use it, the context is sufficient for an agent to decide. It could have mentioned alternatives for full email access, but it's adequate.

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 fully takes on transparency. It explains header handling, subject prefixing, the effect of as_attachment (inlines or attaches original), and the save_to_sent option. This comprehensively discloses behavioral traits.

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 somewhat lengthy due to the parameter list but is well-structured with a clear intro, distinction from sibling, and bullet-style parameter explanations. It is appropriate for the parameter count.

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 complexity (10 parameters, no output schema, no annotations), the description covers essential behavioral aspects and parameter usage. It could be more detailed on failure modes or permissions, but it is adequately complete for most use cases.

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

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

Schema description coverage is 0%, so the description must carry the load. It explains all 10 parameters with meaningful details, especially as_attachment and body, adding value beyond the schema's title fields.

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

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

The description clearly states 'Forward an email to new recipients' and distinguishes it from reply_email by explaining that it creates a new thread without In-Reply-To or References headers and adds a deduped 'Fwd:' subject prefix.

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

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

The description explicitly contrasts forward_email with reply_email, which helps the agent choose between them. It does not explicitly state when not to use, but the differentiation is clear.

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

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

The description details the return dict contents and notes the significance of uidvalidity changes. However, it does not explicitly state that the operation is read-only, nor does it mention error cases like missing folders. With no annotations, more explicit behavioral context would be beneficial.

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, listing return keys clearly in a bullet-like format. Every sentence contributes to understanding the tool's output, with no extraneous text.

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 return format well but misses error scenarios, permission requirements, and the fact that the folder must exist. For a simple tool, it is partially complete but leaves gaps.

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

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

Despite 0% schema description coverage, the description does not describe the 'folder' parameter beyond a brief mention in the return dict. The parameter's purpose, constraints, or format are not explained, forcing reliance on the schema 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 'Get counts and state for a folder via IMAP STATUS', specifying the action and resource. It is distinct from sibling tools like 'get_unread_summary' which returns only unread counts, but does not explicitly differentiate itself.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'get_unread_summary' or 'inspect_email'. There is no mention of prerequisites or conditions for use.

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?

Without annotations, the description explains the internal behavior: iterating LIST, skipping Noselect folders, calling STATUS on each, and returning a dict with keys for each folder plus a _summary. It does not mention error handling or performance limitations, but the read-only nature and basic flow are well covered.

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 only three sentences, front-loaded with the main purpose, then concisely explaining the method and efficiency benefit. No wasted words.

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

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

Given the tool has no parameters and no output schema, the description fully explains what it does and the structure of the return value (dict with folder keys and _summary with totals). It is complete for the tool's simplicity.

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?

There are zero parameters, so the description does not need to add parameter semantics. Schema coverage is 100% trivially, and the baseline for 0 params is 4.

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 aggregates unread and total message counts across all selectable folders, distinguishing it from the per-folder sibling get_folder_status. It uses specific terms like 'LIST', 'Noselect', and 'STATUS', making the action 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 explicitly recommends using this tool over calling get_folder_status per folder for efficiency, because it uses a single IMAP session. This provides clear when-to-use guidance and names a direct alternative.

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 fully discloses behavior: uses FETCH BODYSTRUCTURE + header subset, returns in milliseconds, lists exact return fields (subject, from, to, date, size, MIME parts with part number, type, size, charset, filename, disposition). No contradictions.

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?

Well-structured with clear sections and bullet points for return fields. Front-loaded main purpose. Slightly lengthy due to detail, but each sentence adds value. Could be shortened slightly without losing 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?

Given 2 required parameters and no output schema, the description provides complete context: what it does, when to use, and detailed return structure. Covers all necessary information for an agent to invoke 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 has 0% description coverage, but parameters 'folder' and 'email_id' are self-explanatory from tool name. Description implies usage context but does not explicitly describe parameter semantics beyond the obvious. Baseline 3 is appropriate as the description adds minimal parameter meaning.

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

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

Description clearly states 'Inspect an email's headers and MIME structure WITHOUT downloading bodies', specifying the action and resource. It distinguishes from siblings like 'read_email' and 'fetch_part' by emphasizing the lightweight nature and the part number usage.

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

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

Provides three explicit ideal use cases (previewing large emails, deciding which attachment to download, bulk processing) and indirectly suggests alternatives like 'fetch_part' for downloading attachments. This helps the agent decide when to use this tool.

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

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

No annotations are provided, so the description carries full burden. It discloses that folder names are decoded from IMAP UTF-7 and lists the return fields with their purpose. It does not mention any side effects or prerequisites, but for a read-only list operation, this is sufficient.

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, using a single sentence for the main purpose and a concise bullet list for the return fields. No wasted words.

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

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

Given the tool's simplicity (no parameters, straightforward listing), the description covers the essential output fields and their usage. Minor omission: no mention of potential large results or pagination, but not critical.

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 no parameters, and schema coverage is 100% (vacuously). The description does not add parameter-specific info, but that is unnecessary. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'List' and the resource 'all mail folders in the Yandex mailbox', which is specific and distinguishes it from sibling tools like create_folder or delete_folder.

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 explains that the imap_name field should be used for other operations like search_emails, providing context for when to use this tool. However, it does not explicitly mention when not to use it or compare it with alternatives like get_folder_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?

No annotations provided, so description carries full burden. It only states it adds a flag but does not disclose side effects, reversibility, or authorization needs.

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

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

Single sentence, no wasted words. Could be slightly improved with front-loading, but it is concise.

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

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

Given no output schema and 0% parameter coverage, the description is too minimal. It does not explain return values, error conditions, or behavior if email is already answered.

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%; description adds no meaning beyond parameter names. 'folder' and 'email_id' are not explained.

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?

Clearly states what the tool does: 'Mark an email as answered (adds \Answered).' Verb-resource combination is specific and distinguishes from siblings like mark_read, mark_flagged.

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

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

No guidance on when to use this tool versus alternatives like set_flags or bulk_set_flags. No context for prerequisites or typical scenarios.

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 fully disclose behavior. It indicates a write operation via IMAP but does not describe error conditions (e.g., missing email), side effects, or whether the operation is reversible. This minimal disclosure is insufficient for safe invocation.

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

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

The description is very short (one sentence), which is concise but not structured effectively. It front-loads the core action but omits essential details that could be added without verbosity.

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

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

For a tool with 3 parameters, no output schema, and no annotations, the description is incomplete. It does not explain return values, error handling, or confirm the effect on the email's flagged state. Sibling tools like bulk_mark_flagged suggest batch operations exist, but no comparison is given.

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 adds no meaning to any parameter. For instance, the 'flagged' boolean parameter is not explained (true=star, false=unstar), nor is the format of 'folder' or 'email_id' given. The description fails to compensate for the lack of schema descriptions.

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

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

The description clearly states the action (star/unstar) and resource (email) via the \Flagged IMAP flag, distinguishing it from flags like \Answered or \Read used by sibling tools. However, it does not explicitly say that the action toggles based on the boolean flag.

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

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

No guidance is provided on when to use this tool versus alternatives like bulk_mark_flagged (for multiple emails) or set_flags (for arbitrary flags). No prerequisites or context for when to star vs unstar are given.

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

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

With no annotations, the description carries full burden. It discloses the action and the flag added, but does not mention side effects, prerequisites (e.g., email existence), or behavior when already read. Adequate but not fully transparent.

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 wasted words, making it concise. However, it could be slightly more detailed without harming conciseness.

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

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

Given no output schema, the description should hint at return behavior, but it does not. It also lacks details on errors. It covers the basic action but is minimally complete for a simple tool.

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

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

Schema description coverage is 0% and the description does not explain the parameters (folder, email_id). The agent must infer meaning from names only, which is insufficient for correct invocation.

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

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

The description clearly states the tool marks an email as read and mentions the underlying mechanism (adds \Seen). It distinguishes from siblings like mark_unread and bulk_mark_read through the name and single email focus.

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

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

No guidance on when to use this tool versus alternatives like mark_unread or bulk_mark_read. The description only states what it does, not the context for appropriate usage.

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

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

The description discloses the behavioral trait of removing the \Seen flag, which is a key effect. However, with no annotations provided, it does not mention permissions, idempotency, or what happens if the email is already unread. It is adequate but not comprehensive.

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

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

The description is extremely concise: one sentence of 9 words. Every word is necessary and there is no redundancy. It is perfectly front-loaded with the action.

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 low complexity (2 required parameters, no output schema), the description is minimally complete. It states the core functionality but omits usage context, parameter details, and behavioral constraints. It meets a basic standard but leaves gaps for an AI agent.

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

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

With 0% schema description coverage, the description must explain the parameters but does not. It adds no meaning beyond the schema. The parameters 'folder' and 'email_id' are not described, leaving their format or constraints unclear.

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: 'Mark an email as unread (removes \Seen).' It specifies the verb (mark) and resource (email), and differentiates from sibling tools like mark_read and mark_flagged by mentioning the removal of the \Seen flag.

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

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

No guidance is provided on when to use this tool versus alternatives such as mark_read, mark_flagged, or bulk_mark_unread. The description lacks context about prerequisites or typical use cases.

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

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

Annotations are absent, so the description must cover behavioral traits. It states the action (move) and that it returns a confirmation, but it does not disclose side effects (e.g., if flags change, if the move is reversible) or details about the move operation. This is minimally adequate for a simple tool.

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

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

The description is extremely concise: one sentence for purpose followed by a structured list of arguments. No unnecessary words or redundancy. Every line is functional.

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 3 required params, no output schema, and no annotations, the description covers the basic action and return value but lacks context about error handling, whether the move is permanent, or how it differs from a copy. The sibling 'bulk_move' suggests a need to specify this moves a single email, but that is not explicit.

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 compensates by explaining each parameter: folder as source, email_id, and destination as destination folder name. This adds meaning beyond raw property names and types, though it lacks format constraints or examples.

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 'Move an email to another folder.' This specifies the verb 'move' and the resource 'email' to a destination folder, distinguishing it from siblings like bulk_move (multiple) and forward_email (copy to recipient).

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

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

No guidance is given on when to use this tool vs alternatives. With siblings like bulk_move, an agent would benefit from knowing this moves a single email, but the description does not provide any usage context, prerequisites, or exclusions.

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

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

No annotations provided, so the description carries full burden. It describes the return values and implies a read-only operation. No side effects or contradictions are present.

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, with a clear first sentence and well-structured arguments and return info. No fluff.

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

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

Given the tool's simplicity and lack of output schema, the description adequately covers return fields and arguments. Sibling tools are many but not compared; however, the core information is 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 description coverage is 0%, but the description adds meaning: folder is the mailbox folder, email_id is from search_emails(), which goes beyond the schema's simple 'string' type.

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 it reads full email content by ID, and provides the return fields. It distinguishes from siblings like search_emails (which finds IDs) and delete_email (different action), making the tool's purpose unambiguous.

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

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

The description indicates the email_id comes from search_emails() result, implying a prerequisite. It does not explicitly state when not to use (e.g., for attachments use download_attachment), but the context is clear.

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

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

With no annotations, the description must fully disclose behavior. It reveals that names are auto-encoded to UTF-7, but fails to mention if renaming is destructive, what happens to subfolders, whether the folder must exist, or system folder restrictions.

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

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

The single-sentence description is concise and front-loaded with the main purpose. However, it could include additional concise behavioral details without becoming verbose. It earns its place but is slightly under-specified.

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

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

Given the tool's simplicity (2 required string params, no output schema), the description covers purpose and encoding but omits important context: return values, error conditions, prerequisites, and side effects. It is incomplete for full usage understanding.

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% (no parameter descriptions), so the description must compensate. It only adds the auto-encoding note, which provides some value. Parameters are self-explanatory from their names, but the description does not clarify format, length limits, or examples.

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 (rename) and the resource (mail folder). It is specific and understandable, though it does not distinguish from sibling folder tools like create_folder or delete_folder, which have different purposes.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any prerequisites, context, or exclusion conditions. The auto-encoding note is more behavioral than usage advice.

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

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

With no annotations, the description fully discloses behavior: it fetches headers, constructs threading, determines recipients (Reply-To or From, including others for reply_all), and saves to Sent by default. This satisfies the transparency burden, though it doesn't cover error cases or auth requirements.

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 well-structured with purposeful line breaks, front-loaded purpose, and concise bullet points for arguments. Every sentence contributes meaning without redundancy.

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

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

The description covers the tool's operation thoroughly given 7 parameters and no output schema. It lacks mention of return value or error handling, but overall provides sufficient context for an agent to use the tool effectively.

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 compensates by explaining each parameter: body, html, reply_all, attachments, save_to_sent are described with clear semantics. Folder and email_id are minimally explained but adequate. This adds significant value over the bare schema.

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

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

The description clearly states 'Reply to an email with correct threading headers', specifying the verb (reply) and resource (email). It distinguishes from sibling tools like forward_email and send_email by detailing threading behavior (RFC 5322).

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

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

The description implies usage for replying rather than forwarding or sending new emails through its threading details, but lacks explicit when-to-use or alternatives. It does not state explicit exclusions, yet the context is clear enough for an agent to differentiate.

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 fully discloses behavioral traits: IDs are IMAP UIDs stable within UIDVALIDITY, folder name encoding details, query syntax examples, and return type. This exceeds expectations for an unannotated tool.

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

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

The description is well-structured with a clear purpose sentence followed by parameter details in bullet-like format. It is slightly verbose but all information is useful and not redundant.

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 complexity (4 params, query string nuances, IMAP specifics), the description covers all necessary context: return type, ID stability, folder encoding, pagination, and query examples. An output schema exists, but the description adds value beyond 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?

Despite 0% schema coverage, the description thoroughly explains all four parameters: folder (default, name formats, encoding), query (with multiple examples), limit (default), and offset (default, pagination). This compensates fully for the schema's lack of descriptions.

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

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

The description clearly states 'Search emails in a folder.' and specifies the returned data (list of email summaries with id, subject, from, date). It uniquely identifies the tool's function among siblings, none of which are search tools.

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

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

The description provides context for using the 'folder' parameter (e.g., 'Use list_folders() to see available folders') and gives query examples. It lacks explicit when-not-to-use statements, but as the only search tool, guidance is sufficient.

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 fully discloses behavioral traits: security risk of file exfiltration (explicit warning), logging of attachment paths, and the non-fatal fallback behavior of save_to_sent. This goes well beyond basic description.

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

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

The description is well-structured with 'Args' and 'Returns' sections. Each sentence adds value, though it is slightly verbose (e.g., including full SECURITY warning). Minimal waste, but could be tighter.

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 8 parameters, no output schema, and no annotations, the description covers all necessary aspects: parameter behavior, security context, failure handling, and return value. It addresses Yandex-specific quirks (auto-save gap), making it fully complete for an agent.

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

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

Schema coverage is 0%, so the description must add meaning for all 8 parameters. It does so clearly: explains comma-separated format for multiple recipients, html flag meaning, attachments as absolute file paths, and save_to_sent behavior including Yandex-specific rationale.

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 immediately states 'Send an email via Yandex SMTP', providing a specific verb and resource. The detailed parameter list distinguishes it from siblings like forward_email by focusing on SMTP sending with full control over recipients, body format, and attachments.

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 does not explicitly state when to use this tool versus alternatives such as forward_email or reply_email. It implies usage for composing new emails, but no direct comparison or exclusions are provided. The security warning suggests user approval context, but usage guidance remains implicit.

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

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

With no annotations, the description carries the full burden. It discloses that flags can be added/removed and that a confirmation is returned. However, it does not mention idempotency, error handling, or prerequisites like authentication or folder existence.

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 fairly concise but includes an 'Args' block that breaks the typical MCP narrative flow. It could be tightened by integrating the parameter explanations into a single paragraph without line breaks.

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 operation and parameters but omits context like error scenarios, rate limits, and best practices. Without annotations or output schema, the agent is left with gaps in understanding the tool's full 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?

Schema coverage is 0%, so the description provides the only documentation for parameters. It explains that 'email_id' comes from search_emails, and 'add'/'remove' are arrays of flags. However, it lacks details on folder format, flag validation, and behavior when both add and remove are 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 clearly states 'Set or clear IMAP flags on a message' and lists common system flags. It differentiates the tool from its sibling 'bulk_set_flags' by implication (single email), but does not explicitly contrast them.

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

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

No guidance is provided on when to use this tool versus bulk alternatives or other flag-manipulation tools. The description assumes the agent knows to use this for single messages, but does not state that explicitly.

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