Fluxmail

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states a key side effect: 'The draft stays in the Drafts folder, so the content is not lost.' This meaningfully clarifies what the cancellation does and does not do. It could further mention errors for invalid scheduleId or whether cancellation is reversible, but for a single-parameter operation this is reasonably 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?

Two sentences, no filler. The action and parameter source are front-loaded, and the draft-preservation note is a valuable addition without bloat.

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 one required parameter and no output schema, the description is complete. It states the operation, identifies the parameter's source, and clarifies the side effect. An agent has enough information to call 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 schema only defines scheduleId as a minLength-1 string with no description, so coverage is 0%. The description compensates by explaining that scheduleId identifies a pending scheduled send and comes from send_email with sendAt or list_scheduled_emails. This gives the agent practical knowledge for populating the parameter, though it does not specify format beyond the source.

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 and resource combination: 'Cancel a pending scheduled send by scheduleId.' It clearly identifies the operation as distinct from siblings like delete_draft or send_email, and it names the source of the scheduleId, eliminating ambiguity about what the tool acts on.

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 implicitly tells the agent when to use this tool: when a scheduled email exists and needs to be canceled. It explains where to obtain scheduleId (from send_email with sendAt or list_scheduled_emails), which is a clear usage prerequisite. It does not explicitly contrast with alternatives like delete_draft, but the mention that the draft remains makes the distinction reasonably 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 carries the behavioral disclosure burden. It adds useful behavior ('recipients/subject are derived', 'replyAll for reply-all'), but it does not mention output/return behavior, the fact that nothing is sent, or any side-effect details beyond creating a draft.

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

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

Two short sentences with no filler. The core action is front-loaded, and the reply-draft qualification is presented immediately in the second sentence, so every part earns its place.

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

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

Given the rich schema coverage and the tool's relatively low-risk 'create draft' semantics, the description is largely complete. It could mention what the tool returns or explicitly confirm it does not send, but the combination of name, description, and schema gives an agent enough to invoke it correctly.

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

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

Schema description coverage is 91%, so the schema already documents nearly all parameters in detail. The description adds a small amount of semantic linkage by explaining that replyToMessageId drives derived recipients and subject, but it does not meaningfully extend the schema's 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 opens with a specific verb and resource ('Create a draft'), making the action unmistakable and differentiating it from siblings like update_draft, send_email, and delete_draft. It also immediately introduces the reply-draft variant, which is a distinct mode of this tool.

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

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

The description gives clear situational guidance: for a reply draft, pass replyToMessageId, and use replyAll for a reply-all. It does not explicitly contrast with send_email or update_draft, but the context of drafting versus sending or updating is strongly implied.

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

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

Annotations provide destructiveHint: true, indicating deletion is destructive. The description adds no additional behavioral context (e.g., irreversibility, required permissions, side effects). Beyond the annotation, transparency is minimal.

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 (one sentence) but overly minimal, lacking essential information. It could be expanded without losing conciseness to improve 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 destructive action with two parameters and no output schema, the description is incomplete. It omits behavioral details, prerequisites, and return information, leaving the agent with insufficient context to use the tool safely.

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 50% (accountId has description, draftId does not). The description does not explain the parameters or their roles, failing to compensate for the low coverage. No parameter information is provided in the description.

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 'Delete a draft' clearly states the verb and resource, but it does not differentiate from sibling tools like update_draft or create_draft. It is clear but could be more precise about scope or prerequisites.

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 delete_draft versus other tools (e.g., update_draft). The description does not mention any context, alternatives, or exclusions, leaving the agent to infer 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?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds the useful behavioral detail that the result is returned as an embedded MCP resource, but it does not disclose other traits such as size limits, authentication needs, or error behavior.

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

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

A single sentence containing exactly the essential information: the action, the resource, and the output type. No filler or redundant wording; the main behavior is 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?

For a simple read-only download, the description plus schema is mostly sufficient: required IDs are clear and the return form is stated. However, it lacks any mention of where to obtain messageId/attachmentId (beyond the schema hint), no size/format caveats, and no routing to relevant sibling tools, leaving some context unstated.

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 descriptions cover accountId and attachmentId, and messageId is self-explanatory from its name. The description itself adds no parameter-level meaning, but with 67% schema coverage and clear parameter names, the agent can infer the required identifiers without additional explanation.

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

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

States a specific action ('Download'), a precise resource ('an email attachment'), and the output form ('as an embedded MCP resource'). This clearly distinguishes it from sibling tools like get_email or list_emails, which handle message content or metadata, not attachment downloads.

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 versus alternatives. Sibling tools such as get_email or get_thread are not referenced, and no conditions, exclusions, or prerequisite steps 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?

The description goes beyond the destructiveHint annotation by spelling out concrete behavior: the original body is quoted, the subject becomes 'Fwd:', attachments are included unless includeAttachments=false, and a comment appears above the forwarded content. This meaningfully discloses what the tool does without contradicting the annotation.

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

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

The description is two sentences, front-loads the core action, and every clause adds useful operational detail. There is no filler, redundancy, or schema repetition.

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

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

For a 7-parameter tool with no output schema and only destructiveHint as an annotation, the description covers the essential behavior, attachment defaults, and comment placement. It does not state the return value or explicitly confirm that a new message is sent immediately, but the forwarding semantics largely make this clear.

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 71%, and the description adds meaning for comment ('appears above the forwarded content') and includeAttachments ('original attachments included unless includeAttachments=false'). It leaves messageId and comment without schema descriptions, but the overall forward behavior and recipient emphasis make them reasonably inferable.

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

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

The description names a specific verb and resource ('Forward an email to new recipients') and details the exact forwarding behavior: quoted original body, 'Fwd:' subject, and attachment handling. This clearly distinguishes it from sibling tools like send_email or create_draft, even without naming 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?

The description implies the use case through the word 'Forward' and the outlined behavior, but it does not explicitly state when to choose this over send_email, create_draft, or update_draft. There are no exclusions or alternative-routing hints, so usage guidance is only implicit.

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

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

The annotations already declare readOnlyHint=true, indicating a safe read operation. The description adds that the tool returns body, recipients, and attachment metadata, but does not disclose other behaviors like rate limits, error handling, or that attachments are returned as metadata only.

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

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

The description is a single sentence that is front-loaded with the core purpose. Every word is necessary and adds value, with 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?

For a simple fetch tool with no output schema, the description adequately covers the key return data. However, it lacks mention of potential error conditions or the fact that attachments are returned as metadata only. Overall, it is reasonably complete for the complexity level.

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 50% (only accountId has a description). The description does not clarify the meaning of messageId (e.g., that it is obtained from list_emails) or that accountId is optional. It fails to compensate for the missing schema descriptions.

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

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

The description uses the specific verb 'Fetch' and clearly states the resource 'one email in full', listing the returned components (body, recipients, attachment metadata). This distinguishes it from sibling tools like list_emails (which lists headers) and get_thread (which returns a thread).

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 provide any guidance on when to use this tool vs alternatives such as list_emails or search_emails. No context about prerequisites (e.g., needing a messageId from list_emails) or when not to use it is 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?

The readOnlyHint annotation already indicates a safe read operation. The description adds context about checking connection status and re-auth needs, but does not detail the output format or authentication requirements beyond that.

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, thoroughly front-loaded with the purpose, and every word adds value. No wasted content.

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

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

Given zero parameters and no output schema, the description covers the key aspects: status categories (account connection, scheduled-send, admin plan details) and a usage tip. It is complete for an agent to decide when to call.

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 no parameters, so schema coverage is 100%. The description does not need to elaborate on parameters, and it appropriately adds no redundant info.

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 reports account connection and scheduled-send status, plus plan details for admins. It distinguishes this tool from sibling tools like list_accounts by focusing on status and re-authentication needs.

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 says 'Call this first if other tools fail; it reports accounts that need re-authentication,' providing a clear when-to-use instruction and a troubleshooting scenario.

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

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

Annotations already declare readOnlyHint=true. Description adds that it returns all message bodies, which is consistent and mildly additive, but does not disclose pagination, threading logic, or any side effects beyond read-only 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?

Single sentence that is front-loaded with purpose, no redundant words. Achieves maximum clarity with minimum 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?

With no output schema, the description could clarify what 'full conversation thread' means (e.g., message order, attachments). It is adequate but not fully informative for a read operation that returns a complex object.

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?

Description does not mention either parameter. Schema coverage is 50% (only accountId has a description). The description fails to add meaning beyond the schema, leaving the agent to infer threadId's role from context 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?

Description explicitly states 'fetch a full conversation thread with all message bodies', using a specific verb and resource. It clearly distinguishes from siblings like get_email (single email) and list_emails (no bodies).

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

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

No explicit guidance on when to use this tool versus alternatives. The description implies it's for full threads but does not mention when not to use or provide decision 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?

Annotations already declare readOnlyHint=true, so the description does not contradict. It adds the specific fields returned, but does not disclose any additional behavioral traits (e.g., rate limits, authentication requirements, or whether it returns all accounts without pagination). The description adds some value beyond annotations but is not rich.

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

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

The description is a single, well-structured sentence that conveys all essential information without any wasted words. It is appropriately sized for the tool's simplicity.

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

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

Given the tool has no parameters and a straightforward purpose, the description is largely complete. It mentions the returned fields. However, it could optionally note ordering or whether it returns all connected accounts, but this is not critical 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?

There are zero parameters, so the baseline is 4. The description adds meaning by listing the fields returned, which goes beyond the empty schema. No further parameter semantics are needed.

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 a clear resource 'connected email accounts', and enumerates the fields returned (id, provider, email, status, capabilities). This clearly distinguishes it from sibling tools like list_emails or list_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 implies usage by stating what the tool does, but does not provide explicit guidance on when to use it versus alternatives (e.g., when to use list_accounts vs. get_status or search_emails). No 'when not to use' or specific context is 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?

readOnlyHint already establishes the safety profile, and the description adds behavior beyond that: metadata with optional previews, filtering by multiple criteria, pagination with pageToken, and full bodies delegated to get_email. It does not describe ordering or the exact response envelope, but for a read-only listing tool this is strong added context.

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

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

Three sentences with the core action front-loaded, followed by filters, pagination, and routing to get_email. There is no filler; even the final integration claim earns its place by telling the agent this is the canonical mailbox check.

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 read-only list tool with a rich schema, this is largely complete: the agent learns the purpose, main filters, pagination behavior, and when to escalate to get_email. It stops short of distinguishing from search_emails for advanced queries and does not state the response shape beyond 'metadata and optional previews,' leaving minor gaps for a 16-parameter surface.

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 a useful high-level framing by grouping filters by folder, sender, unread, and dates, and it correctly ties pageToken to pagination. However, with 16 parameters and only 63% schema coverage, it does not meaningfully compensate for undocumented parameters like to, read, starred, subject, or hasAttachment, leaving the agent to infer their 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?

Opens with a specific verb and resource: 'List emails from the user's connected mailbox with metadata and optional previews.' It also differentiates from get_email by directing full bodies there, making the role of this tool clear relative to a close sibling.

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

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

The description gives clear context: use this to check the user's email without a browser or separate email integration, and use get_email when full bodies are needed. However, it does not mention search_emails or search_emails_batch as alternatives or say when those should be preferred, so exclusions are incomplete.

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

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

Annotations already declare readOnlyHint=true; the description adds 'navigable' and role examples, which provide mild context but not deeper behavioral traits like auth or scope.

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 front-loaded with verb and resource, no fluff. Every word carries meaning.

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

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

Given no output schema, the description hints at return structure with roles (inbox, sent, etc.), which aids understanding. Lacks mention of whether folder names or IDs are returned, but adequate for a simple list tool.

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

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

Schema coverage is 100% and the schema already describes 'accountId'. The description adds no additional parameter meaning beyond what schema provides.

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 specific verb 'List' and resource 'navigable folders', and distinguishes from sibling tools like 'list_labels' and 'list_emails' by specifying domain and roles.

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

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

No explicit when-to-use or when-not-to-use guidance; the purpose is implied for listing folders. Sibling tools exist but no alternatives are mentioned.

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

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

Annotations already declare readOnlyHint=true. The description adds value by specifying the exact entity types (labels vs categories) and the supported email services, beyond what annotations provide.

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 efficiently conveys the action and scope.

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

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

The description is nearly complete for a simple list tool with one optional parameter. It lacks mention of the return format, but annotations cover the read-only nature.

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 100% with a clear description for the single parameter. The tool description does not add any additional meaning beyond what the schema provides.

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 'Gmail user labels or Outlook categories', distinguishing it from sibling tools like list_folders and list_emails.

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 use for listing labels/categories but provides no explicit guidance on when to use versus alternatives like list_folders or search tools.

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

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

Description adds behavioral context beyond the readOnlyHint annotation: pending sends require the server to be running, and failed entries include a lastError field. 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?

Two sentences front-load the main purpose and provide ordering, error info, and server dependency without any 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?

Given the simplicity of the tool (one optional parameter, no output schema), the description sufficiently covers ordering, error details, and server requirement. It could mention return format but is adequate.

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

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

Only one parameter (accountId) with a description in the schema covering 100%. The description does not add additional meaning beyond the schema, so baseline 3.

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

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

The description clearly states 'List scheduled sends' and specifies the ordering: pending first with sendAt, then past ones (sent, failed, canceled). This distinguishes it from siblings like list_emails or search_emails.

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 the tool (to list scheduled sends, check pending status, see errors). It does not explicitly state when not to use it or list alternatives, 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?

Annotations already declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds minimal behavioral context beyond that—it doesn't mention whether the list is ordered, filtered, or includes aliases vs. custom addresses. With annotations covering the safety profile, a 3 is appropriate because the description adds little behavioral 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 concise sentence that front-loads the action and resource. It earns its place with no wasted words, though it could add a bit more context without becoming verbose.

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

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

For a simple read-only list tool with one optional parameter and no output schema, the description is mostly adequate. However, it doesn't clarify what 'sender addresses' includes (e.g., aliases, custom domains) or what the return format looks like, which could leave an agent uncertain about the result. The annotations cover safety, but the description could be slightly richer.

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 100%, so the schema already documents the accountId parameter. The description adds no additional meaning beyond what the schema provides, so the baseline 3 is correct.

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

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

The description states a specific verb ('List') and resource ('sender addresses available for an account'), which clearly identifies the tool's function. It doesn't explicitly distinguish it from siblings, but the resource is unique enough among the listed tools that an agent can infer its purpose.

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

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

The description implies usage context: it lists sender addresses for an account, and the schema notes the accountId is optional when exactly one account is connected. However, it doesn't explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites beyond the schema's optional account note.

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

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

Annotations already mark destructiveHint=true; description adds that actions are 'allowed for this connection', hinting at permissions, but does not elaborate on side effects (e.g., irreversibility of delete).

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, front-loaded sentences with no redundant information.

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

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

With no output schema, the description does not explain return values (e.g., number of modified messages, errors). For a batch mutation tool, this is a notable gap, but the description is minimally adequate.

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

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

Adds conditional logic linking 'action' to required parameters (move→folder, addLabels/removeLabels→labels), which is not encoded 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 specifies a clear verb-resource pair ('Batch-modify emails') and distinguishes this tool from sibling tools that handle single emails, drafts, or read-only operations.

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 conditional guidance for 'move' and 'label' actions (requires folder/labels), but lacks explicit when-to-use vs. alternatives like get_email or create_draft.

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

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

Annotations already declare readOnlyHint=true, and the description does not contradict that. It adds some behavioral context by clarifying the one-account scope and the supported query syntax fields, but it does not disclose pagination behavior, default folder exclusions, provider-specific caveats, or response shape.

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 compact sentences with the action, resource, and scope front-loaded, followed by a concise enumeration of syntax features. There is no filler, redundancy, or repetition of schema details.

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?

A 16-parameter search tool with no output schema needs more than a two-sentence description. It omits result format and pagination, when to prefer search_emails_batch or list_emails, and default search scope and provider-specific behavior. The parameter descriptions fill some gaps, but top-level usage and output context are still missing.

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 63%, and the description adds valuable meaning beyond the schema by explaining what the portable query syntax accepts: text, from:, to:, subject:, in:, read/starred states, attachments, and date filters. This is especially useful because the schema's query field only says 'Typed portable search syntax'. It does not cover every parameter, but the core search parameters are meaningfully 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?

The description uses a specific verb ('Search') and resource ('one account') and introduces 'typed portable syntax', which clearly differentiates it from ordinary listing. It does not explicitly name sibling tools, but the scope and syntax focus are enough to convey the tool's role.

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

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

There is no explicit when-to-use or when-not-to-use guidance. It does not mention search_emails_batch for multi-account searches, list_emails for simpler listing, or get_email for retrieving a known message. The intended usage must be inferred from the tool name and sibling list.

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 readOnlyHint true already declared, the description adds useful behavioral context: 'portable query' indicates query syntax portability across accounts, and 'one result group per account' explains the output grouping. It does not cover pagination or error behavior, but the annotation lowers the bar for safety disclosure.

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

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

A single, front-loaded sentence with zero filler words. It communicates the essential scope, input, and output grouping in the most efficient way possible.

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 14 parameters, no output schema, and only 43% schema description coverage, the description is too sparse to provide complete guidance. It omits parameter details, return value structure, pagination semantics, and edge-case behavior, leaving an agent to guess for non-trivial 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 only 43%, leaving parameters like to, from, read, subject, starred, and hasAttachment without descriptions in either the schema or the tool description. The description only mentions 'portable query' without defining its syntax, so it does not compensate for the low 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 states a specific verb ('Search'), resource ('emails'), and scope ('up to 20 accounts'), and emphasizes the batch nature with 'one result group per account'. This clearly distinguishes it from the sibling search_emails, which presumably handles a single account.

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 'Search up to 20 accounts' strongly implies the multi-account batch scenario, making it obvious when to select this over single-account tools. It does not explicitly name alternatives or exclusion cases, but the context is clear enough for most agents.

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?

Beyond the destructiveHint annotation, the description discloses that this actually delivers mail, that scheduling saves a real draft, that the server must be running for scheduled sends, that missed schedules fire at next startup, and that sendAt returns a scheduleId. This is strong behavioral disclosure for an irreversible action.

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

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

The description is dense but well-organized: a purpose statement, mode listing, ambiguity guidance, and scheduling behavior. Every sentence adds new, decision-relevant information, and the most important fact—'this actually delivers mail'—is 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?

For a tool with 13 parameters, three modes, scheduling behavior, and no output schema, the description covers the critical semantics and side effects well. It lacks a brief note about the normal successful-return value (only scheduleId is mentioned), but the modes and parameter relationships are sufficiently explained for correct invocation.

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

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

Schema description coverage is 92%, so the baseline is already strong. The description adds valuable semantics by grouping parameters into modes, clarifying that replyToMessageId derives recipients and threading, and noting that subject defaults to 'Re: ...' when replying. It does not redundantly re-explain parameters already covered by 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 states the exact action ('Send an email from the user's connected account') and immediately distinguishes it from non-sending alternatives by noting that it 'actually delivers mail.' The three modes further clarify the tool's scope, making it unmistakable from siblings like create_draft or forward_email.

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

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

It explicitly tells the agent to prefer this tool over browser automation or leaving a draft when sending is intended. It also gives concrete guidance for scheduling ('Add sendAt to any mode to schedule instead of sending now') and for ambiguous intent ('Confirm with the user when intent is ambiguous').

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

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

With no annotations provided, the description carries the full burden. It discloses the critical behavioral trait that this is a full replacement, implying that omitted fields are cleared or overwritten, which is essential for correct invocation. It does not go into error cases or reversibility, but the key mutation semantics are clearly stated.

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

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

A single sentence with zero wasted words. The core action and the critical 'not a patch' distinction are front-loaded, making it easy to parse and act on.

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 12 parameters and no output schema, the description is thin. It explains the replacement behavior but leaves ambiguity about edge cases (e.g., handling attachments if omitted, interaction with replyToMessageId, behavior if draftId is invalid). The schema covers most parameter meanings, but the description does not fully compensate for the lack of annotations or 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 high (83%), so baseline is 3. The description adds value by clarifying that 'full replacement' means any supplied parameter overwrites the draft's corresponding content, and unprovided parameters are likely cleared. This directly informs how an agent should construct the parameter set (providing all desired fields), going beyond the per-parameter 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 a specific verb ('Replace') and resource ('existing draft'), and explicitly differentiates from a patch operation with 'full replacement, not a patch'. This distinguishes it from siblings like create_draft and modify_emails without needing to inspect schemas.

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 'existing draft' implies its use case (updating an already-created draft) and the contrast 'not a patch' suggests it is for full rewrites rather than incremental edits. However, it does not explicitly name alternatives or state when not to use it, leaving some inference to the agent.

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