Email MCP Server

by 123jixinyu

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.2.3
Disambiguation5/5
Every tool targets a distinct action and resource, from reading (list_emails, get_email, get_emails, get_email_status, search_emails) to writing (send_email, reply_email, forward_email, save_draft, send_draft) to management (move_email, delete_email, mark_email, labels, bulk_action). Even similar operations like add_to_calendar and create_reminder are clearly differentiated by their descriptions.
Naming Consistency5/5
All tool names follow a consistent verb_noun pattern with underscores (e.g., list_accounts, get_email, create_reminder, delete_mailbox). Compound verbs like analyze_email_for_scheduling and check_notification_setup still adhere to the same convention.
Tool Count2/5
With 49 tools, this server is very heavy. The breadth of features (email, calendar, reminders, notifications, templates, analytics) justifies a larger count, but 49 still exceeds the practical limit for an agent to efficiently navigate and select from, making the set feel bloated.
Completeness5/5
The email lifecycle is thoroughly covered: send, reply, forward, draft, schedule, move, delete, mark, label, search, and attachments. The additional calendar, reminder, template, and analytics features address secondary needs, and helper tools like find_email_folder and analyze_email_for_scheduling fill potential gaps.
Average 4.2/5 across 49 of 49 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 5 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
This repository is licensed under LGPL 3.0.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
This repository includes a glama.json configuration file.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=false and destructiveHint=false, so the safety profile is known. The description adds useful context that the email is 'queued locally' and 'sent automatically when the time arrives,' which are behavioral traits beyond the annotations. However, it lacks details on edge cases (e.g., app closure) or how to cancel, so it only partially extends beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no wasted words. It front-loads the primary action and follows with a brief explanation of the queuing behavior. This is appropriately sized and structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a scheduling tool with no output schema, the description covers the main action but does not explain what the tool returns (e.g., a scheduled ID) or any prerequisites beyond the schema parameters. It also doesn't connect to related tools like list_scheduled or cancel_scheduled, leaving some gaps for an agent to discover. Given the tool's simplicity, it is adequate but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with descriptions for all 9 parameters, including required fields like send_at and optional fields like cc. The description does not add parameter-specific semantics, but the schema is self-sufficient, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Schedule an email to be sent at a specific time in the future.' This uses a specific verb ('schedule'), identifies the resource ('an email'), and distinguishes it from sibling tools like send_email (immediate sending) and list_scheduled (viewing scheduled emails).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the use case for future sending ('at a specific time in the future') but does not explicitly contrast it with send_email or mention when not to use it. It also doesn't reference alternatives for managing scheduled emails, such as list_scheduled or cancel_scheduled, leaving the agent to infer the appropriate context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds context about the returned content (preset, rules, custom instructions) but does not disclose any other behavioral traits such as caching, authentication requirements, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that front-loads the action ('Get') and resource ('AI hooks configuration'). Every word contributes meaning, with no redundant or vague phrasing.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple zero-parameter getter with strong annotations, the description is mostly complete. It names the key components of the configuration, though it does not describe the exact return structure or potential edge cases. Given the low complexity, this is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With zero parameters, the schema fully defines the input and the description naturally adds no parameter-level detail. The baseline of 4 for no-parameter tools applies, and the description's mention of return contents partially compensates for the lack of a response schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets the current AI hooks configuration, listing specific components (preset, rules, custom instructions). The verb 'Get' is specific and the resource is well-defined, distinguishing it from related tools like list_presets.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. It does not mention why one would choose get_hooks_config over list_presets or other configuration-related tools, leaving the decision entirely to the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a mutating operation (readOnlyHint=false, openWorldHint=true). The description confirms the action of sending but adds no additional behavioral context such as whether the send is synchronous, whether confirmation is returned, or any side effects beyond actually sending. With annotations covering the basic write nature, a score of 3 reflects minimal added transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
One succinct sentence that front-loads the main action, then lists the key supporting features. Every word contributes to understanding, with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given eight parameters and no output schema, the description is adequate to understand the tool's core purpose and key options. It doesn't cover return behavior or prerequisites beyond the schema, but for a straightforward send action with good schema coverage, it meets the minimum and is slightly better due to clear scope.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% parameter description coverage, so the baseline is 3. The description adds little beyond repeating that CC and BCC are supported and mentioning HTML body, but does not provide format details, syntax, or relationships beyond what the schema already documents.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Send' and names the resource 'a new email', clearly distinguishing from siblings like reply_email, forward_email, and save_draft by emphasizing 'new'. It also mentions key format options (plain text/HTML, CC, BCC), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for new outgoing emails by the phrase 'a new email', but it does not explicitly state when not to use it or name alternatives like reply_email, forward_email, or schedule_email. There is no when/when-not guidance, so it falls at implied usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes beyond the minimal annotations (readOnlyHint=false, destructiveHint=false) by explaining automatic extraction, saving attachments, showing a confirmation dialog on macOS, and returning status codes. However, it does not mention that the confirmation dialog can be bypassed when confirm=false, nor does it explain the meaning of 'no_display' or behavior on Linux without a display.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at four sentences, with each sentence adding value: purpose, extraction behavior, attachment handling, confirmation, and return values. It is well-structured and front-loaded with the core purpose, making it easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (7 parameters, no output schema), the description covers a lot: platform specifics, automatic extraction, attachment saving, confirmation, and return statuses. However, it omits details about the effect of confirm=false, platform differences (e.g., no confirmation on Linux), and what exactly triggers 'no_display'. These gaps prevent a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents each parameter. The description adds context about the email data extraction (ICS, meeting URLs, attendees) but does not provide additional meaning for individual parameters beyond what is already in the schema. It meets the baseline but does not exceed it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Add an email event to the local calendar' with specific verb and resource. It also mentions platform support (macOS/Linux) and distinguishes itself from sibling tools like extract_calendar and list_events by focusing on adding events from email.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear context for when to use the tool (adding email events to calendar) and includes details about automatic extraction. However, it does not explicitly mention alternatives or when not to use it, such as preferring extract_calendar for just retrieving event details, or checking calendar permissions first.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already flag destructiveHint=true, but the description adds specific behavioral detail: 'Removes it from the queue and deletes the associated draft.' This clarifies the side effects beyond the annotation, providing useful context about what gets destroyed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with no filler. Every word adds value, front-loaded with the primary action and followed by the consequence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter destructive tool with annotations and a full schema, the description is sufficiently complete. It doesn't specify error handling or invalid IDs, but these are not essential given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage with a clear description of schedule_id ('Schedule ID to cancel'). The tool description does not add additional parameter meaning, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Cancel' with a clear resource 'a scheduled email', and further explains it removes from the queue and deletes the associated draft. This clearly distinguishes it from sibling tools like schedule_email or list_scheduled.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for canceling a scheduled email but does not explicitly state when to use it vs alternatives, nor does it mention prerequisites like finding the schedule_id first via list_scheduled. No exclusions or alternatives are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds meaningful scope: health, quota, and capabilities. It does not contradict annotations and provides useful behavioral context beyond the read-only flag.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the core function. No fluff; every word contributes. This is a model of conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple health-check tool with one optional parameter, no output schema, and strong annotations, the description is sufficient. It states what is checked and when it's useful. Minor ambiguity in 'capabilities' but not critical for invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (the optional 'account' parameter is fully described). The description adds no parameter details beyond saying 'email accounts', but the schema already does the heavy lifting. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb ('Check') and resource ('connection health, quota, and capabilities for email accounts'). This distinguishes it from sibling tools like list_accounts or get_email_stats, as it is the only tool focused on health/diagnostics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some usage context ('Useful for diagnosing issues') but does not explicitly state when to use this tool over alternatives or mention any exclusions. It implies use for troubleshooting, which is a clear contextual signal.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds value by specifying the type of analytics returned (volume, top senders, daily trends), which is especially useful given the absence of an output schema. 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences (14 words) that directly state the purpose and key output categories. It is front-loaded with the main verb and resource, with zero filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With all parameters documented and safety annotations present, the description adequately covers the tool's purpose and return contents. It could benefit from explicit use-case distinction, but overall it is sufficient for an agent to select and invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides descriptions for all three parameters (account, period, mailbox), covering 100% of semantics. The tool description adds no additional parameter information, so the baseline for high schema coverage applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as retrieving email statistics/analytics, naming specific metrics (volume, top senders, daily trends, read/flagged counts). This distinguishes it from siblings like list_emails or get_email, which fetch individual messages or lists.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
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 is present. The description implies usage for aggregate analytics but does not mention when to avoid it or name alternative tools, so only implied context exists.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so safety profile is covered. Description adds return field list and filtering options, but does not disclose pagination defaults, ordering, or timezone behavior; annotations lower the burden.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, first is action+scope, second gives usage context, third lists return fields. No filler or duplication of schema parameter details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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 good annotations and full schema coverage, description covers purpose, usage, and return shape. It could mention default date range behavior or ordering, but these are schema-documented; overall sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema covers all 5 parameters with descriptions (100% coverage). Description merely restates filtering dimensions without adding syntax, format, or interaction details beyond schema, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description names specific action 'List local calendar events' and clarifies filtering dimensions (title, date range, calendar name), distinguishing it from sibling tools like list_calendars (which lists calendars, not events) and add_to_calendar (which creates events).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
States explicit use cases: check existing events before creating, verify a recently added event. This implies when to use relative to add_to_calendar, though it does not name alternative tools or state when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe-read nature is established. The description adds the status scoping dimension but no further behavioral details like response format or pagination. This is comparable to the calibration example where annotations cover safety and description adds a scope constraint.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short, front-loaded sentences with no redundant phrasing. Every word contributes to the purpose and scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only listing tool, the description adequately covers the purpose and statuses. The schema fully documents parameters, and annotations handle safety. It does not mention the account filter, but this is captured in the schema, so completeness is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with both parameters (status and account) already documented with descriptions and an enum for status. The description repeats the status values but adds no meaning beyond what the schema provides, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description precisely states 'List scheduled emails' and clarifies the statuses it can show (pending, sent, or all). This distinguishes it from sibling tools like list_emails (regular emails) and cancel_scheduled (mutating scheduled emails).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies the tool is for viewing scheduled emails by status, which provides context for when to use it. However, it does not explicitly name alternatives or state when not to use it, though the sibling list_emails is implicitly different.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate mutating but idempotent behavior. The description adds value by explaining provider-specific effects (ProtonMail folder vs Gmail/IMAP keyword flag), which is not captured in annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action, and contains no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description adequately covers the tool's behavior for its complexity, including provider differences. It lacks a mention of return value, but no output schema exists and the tool is straightforward.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides descriptions for all four parameters (100% coverage). The description does not add additional meaning beyond the schema, meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('remove') and resource ('label from an email'), clearly distinguishing it from sibling tools like add_label and delete_label. It also specifies provider-specific semantics, enhancing clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for removing labels from emails but does not explicitly state when to prefer this over alternatives like delete_label or mark_email. It provides provider context but no exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a non-read-only, non-destructive operation. The description adds minimal behavioral context by mentioning the need to list current paths, but doesn't explain side effects like renaming implications on subfolders or references. With annotations present, a 3 is appropriate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero fluff. The purpose is front-loaded and the additional sentence provides actionable guidance. Perfectly concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a rename tool with three required parameters and no output schema, the description is adequate. It explains the action and gives a pointer to list mailboxes. It could mention what happens to the contents or subfolders, but that level of detail isn't strictly necessary for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 all three parameters. The description doesn't add extra parameter-level meaning beyond the schema, which gives a baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool renames an existing mailbox/folder, with a specific verb and resource. It distinguishes from sibling tools like create_mailbox and delete_mailbox, and even hints at the prerequisite of listing mailboxes first.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly tells the user to use list_mailboxes to see current folder paths, which is a clear prerequisite. However, it does not mention alternatives or when not to use this tool, so it's not a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=false and destructiveHint=false, so the write nature is known. The description adds the behavioral detail of setting In-Reply-To and References headers, which is useful beyond annotations. However, it does not disclose other potential behaviors like authentication requirements or rate limits. This is adequate but not highly transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action and key purpose, and contains no filler. Every word contributes to understanding the tool's function and prerequisite.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description provides the essential context: what the tool does, the threading behavior, and the prerequisite to read the original email first. Combined with comprehensive parameter descriptions in the schema and non-destructive annotations, this is sufficiently complete for an agent to invoke the tool. It could add success/failure expectations but is not critical for a straightforward reply action.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage for all 7 parameters, so the description does not need to explain individual parameters. It adds no extra meaning beyond the schema, and the baseline for high schema coverage is 3. The prerequisite mention of get_email relates to emailId but is already covered in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Reply to an email with proper threading (In-Reply-To & References headers).' This uses a specific verb ('reply') and resource ('email') and adds a distinguishing technical detail (threading headers). It effectively differentiates from siblings like send_email and forward_email by focusing on replying to an existing email.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context by stating 'Use get_email first to read the original,' which is a prerequisite for correct use. It implies this tool is for replying to an existing email, but it does not explicitly exclude forwarding or sending new emails. This meets the standard of clear context without explicit alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only indicate readOnlyHint=false and destructiveHint=false. The description adds critical behavioral context: for ProtonMail it creates a folder under Labels/, while for IMAP it's a no-op because labels auto-create on first use. This is exactly the kind of behavior that goes beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core action, and every sentence adds value. No redundant or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple 2-parameter schema and annotations, the description covers the essential behavior across account types and the no-op case. It doesn't describe return values, but no output schema exists, and the description is sufficient for an agent to invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both 'name' and 'account' already documented. The tool description adds no extra parameter semantics beyond what the schema provides, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Create a new label') and the resource ('label'). It distinguishes behavior across ProtonMail and IMAP but does not explicitly differentiate from the sibling tool 'add_label', which could be confused with create_label.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on when this tool has an effect (ProtonMail creates a folder) and when it is a no-op (IMAP labels auto-created). This implies usage guidance, though it doesn't explicitly state alternatives or when-not-to-use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that it returns unread counts and special-use flags, but does not disclose other behavioral aspects like pagination, error handling, or system folders. Given the annotations, this is adequate but 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose and then a clear prerequisite. Every word earns its place; there is no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple one-parameter tool with no output schema. The description adequately explains what the tool returns (unread counts and special-use flags) and the prerequisite step (list_accounts). Given the low complexity and good annotations, the description is complete for the agent to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with the 'account' parameter already described as 'Account name from list_accounts'. The description reinforces this by telling the user to use list_accounts first, but does not add substantial new meaning beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'List all mailbox folders' with the specific resource (mailbox folders) and additional detail about unread counts and special-use flags. This distinguishes it from sibling tools like list_accounts or list_labels, which target different resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage context: 'Use list_accounts first to get the account name.' This gives a clear prerequisite and suggests the intended workflow. However, it does not explicitly mention when not to use this tool or alternatives, so it falls short of a perfect 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds behavioral context beyond annotations by explaining the keyword search across fields and the pure-filter behavior when query is omitted, which is useful for invoking the tool correctly.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary function, and every sentence adds value. The first sentence states the core purpose, and the second provides a practical usage tip and lists supported filters. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 10 parameters and no output schema, the description covers the main purpose and usage nuance, while the schema documents all parameters. It does not mention pagination or return format, which would be helpful given the page and pageSize parameters, so it is not a 5.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and each parameter has a description, so the baseline is 3. The description adds meaning by clarifying how query and filters interact (e.g., 'omit query to use as a pure filter') and by specifying the search scope (subject, sender, body), which goes slightly beyond the schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches emails by keyword across subject, sender, and body, and also supports filters. It is specific about the resource (emails) and the action (search), but it does not explicitly differentiate from sibling tools like list_emails or get_emails, so it misses the top score for sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context, including how to use it as a pure filter by omitting the query, with a concrete example. It does not explicitly state when not to use this tool versus alternatives, but the filter example and supported filters give practical guidance, earning a 4 rather than a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses important behavioral details beyond the annotations: for ProtonMail it copies the email to a folder, for Gmail/IMAP it sets a keyword flag. This adds meaningful context about side effects and provider variations, complementing the idempotentHint and destructiveHint annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, front-loaded with the core action and immediately followed by necessary provider-specific details. Every word earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description, combined with full schema coverage and clear annotations, provides sufficient context for a simple mutation tool. It explains the functional impact per provider, and no output schema is required. Minor gaps around return values or error conditions are not essential given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for all four parameters, each with a meaningful description. The tool description adds no additional parameter-level semantics beyond what the schema already provides, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states 'Add a label to an email' with a specific verb and resource. The provider-specific behavior (ProtonMail folder copy vs Gmail/IMAP keyword flag) distinguishes it from related tools like create_label or remove_label.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context on how the tool behaves across different email providers, helping the agent understand when to use it. However, it does not explicitly mention alternatives or when not to use this tool, so it falls short of full guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool as read-only and non-destructive, so the bar is lower. The description adds behavioral context by explaining that it returns structured analysis to guide follow-up actions, and it clarifies that no scheduling resource is directly created. It does not contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences long, front-loaded with the primary purpose, and every sentence adds value. It avoids redundancy and clearly states purpose, output, and usage in a compact form.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an analysis tool with well-documented parameters and read-only annotations, the description is largely complete. It explains the tool's role in the scheduling workflow and the nature of the output, though a more specific outline of the structured analysis fields would improve completeness given the absence of an output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All three parameters (account, mailbox, email_id) have descriptions in the schema providing complete coverage. The tool description does not add specific parameter-level semantics beyond indicating the analysis context, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: analyzing an email to detect calendar events and/or reminder-worthy content. It distinguishes itself from sibling tools by positioning as a pre-processing step for scheduling decisions, specifically referencing add_to_calendar and create_reminder as downstream actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says to use this tool as the first step before creating any scheduling resource, and it frames the output as a decision aid between add_to_calendar, create_reminder, both, or neither. This gives clear context and alternatives, though it does not explicitly state 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations (readOnlyHint=false, destructiveHint=false) indicate the tool performs actions but is not destructive. The description adds behavioral transparency by disclosing the specific side effects of each action: preview (no side effect), draft (saves a draft), and send (sends immediately). This goes beyond the annotations, though it does not cover other factors like rate limits or authentication requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the purpose, and contains zero unnecessary words. Every sentence contributes to understanding the tool's function and actions. This is exemplary conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 5 parameters, an enum, and a nested object, the description plus high-quality schema descriptions cover the core functionality. It explains the three action modes and their implications. The lack of an output schema is compensated by the description's focus on actions. However, it does not mention possible errors, return formats, or prerequisites beyond what the schema states, preventing a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers 100% of the parameters with descriptions, including the default and enum values for 'action.' The description adds marginal value by explaining the meaning of each action, but this is largely a restatement of the schema's own descriptions. It does not introduce new parameter-level details, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Apply an email template with variable substitution.' It also enumerates the three actions (preview, draft, send), which distinguishes it from sibling tools like send_email or save_draft, which lack template substitution. The verb 'apply' plus the resource 'email template' is specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context by explaining each action: 'Use action "preview" to see the result, "draft" to save as draft, or "send" to send immediately.' This tells the agent when to choose each action. However, it does not explicitly mention when not to use this tool or alternatives, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already convey destructive intent, and the description adds useful behavioral detail: 'Max 100 IDs per call' and 'Returns success/failure counts.' This transcends the annotation and warns about call limits and result aggregation, though it does not explain partial failure semantics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three concise sentences, front-loaded with the core purpose. Every sentence provides valuable information: action list, id limit, and return format. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a batch tool with a rich schema and annotations, the description is adequate. It covers purpose, constraints, and return counts. It does not mention potential permission requirements or error handling, but these are not essential given the structured fields, and no output schema exists to explain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides descriptions for all parameters (100% coverage), including the max 100 items for 'ids' and the requirement of 'destination' for 'move.' The description replicates this info without adding new semantic value, so a baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb and resource: 'Batch operation on multiple emails by UID list.' It lists supported actions and includes a max limit, distinguishing it from single-email sibling tools like move_email and delete_email.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The term 'Batch operation' implies use for bulk actions rather than single-email operations, and the max 100 IDs constraint provides a usage boundary. However, it does not explicitly mention when to use this instead of siblings, but the clear context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description adds meaningful behavioral context by stating it checks for required OS tools and provides setup instructions. This goes beyond the annotation and clarifies the tool's non-destructive diagnostic nature.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded with the primary purpose, and the second sentence adds necessary detail. Every sentence contributes meaning without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple parameterless tool with annotations, the description adequately covers purpose, behavior, and scope. It could mention the return format explicitly, but given the absence of an output schema, the clarity of 'provides setup instructions' is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the description does not need to explain them. Per the rubric, a baseline of 4 is appropriate for 0-parameter tools, and the description adds no unnecessary parameter details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Diagnose') and resource ('desktop notification support'). It also specifies the platforms (macOS, Linux, Windows) and adds details about checking OS tools and providing setup instructions, distinguishing it from siblings like test_notification and configure_alerts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for diagnosing notification setup but does not explicitly state when to use this tool versus alternatives. It lacks exclusions or references to sibling tools, relying on the reader to infer its role as a diagnostic first step.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is an idempotent write operation. The description adds meaningful behavioral context by explaining the nested folder separator convention and suggesting checking existing folders via list_mailboxes, which goes beyond the structured annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core purpose, and every word earns its place. The advice about separators and list_mailboxes is valuable without unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 2-parameter create tool with idempotentHint and no output schema, the description covers purpose, syntax, and a pre-check step. It doesn't explain potential errors or permission requirements, but those are less critical given the annotations and simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 100% of parameters with descriptions. The description adds a minor but useful clarification about the path separator, but it mostly reinforces what is already in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Create' and resource 'mailbox (folder)', distinguishing it from sibling tools like rename_mailbox, delete_mailbox, and list_mailboxes. It also adds a key detail about nested folder syntax, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on using '/' as a separator and recommends using list_mailboxes to see existing folders. While it doesn't explicitly exclude any scenarios or mention alternatives, the context is clear enough for a create operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is not read-only and not destructive. The description adds valuable behavioral context that the tool 'Shows a native confirmation dialog before adding,' which goes beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, front-loaded with the primary purpose, followed by behavioral transparency and usage guidelines. Every sentence contributes value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the rich schema and annotations, the description provides necessary workflow context (use analyze_email_for_scheduling first) and confirms the confirmation dialog. It does not cover return values, but the lack of an output schema reduces that burden.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with all parameters documented in the input schema. The description itself does not add meaningful parameter semantics beyond what the schema provides, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Create a reminder in macOS Reminders.app from an email.' It uses a specific verb with resource and distinguishes from siblings like add_to_calendar and analyze_email_for_scheduling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context: 'Use for action items, deadlines, and follow-up tasks extracted from emails.' It also recommends a preceding step, analyze_email_for_scheduling, but does not explicitly state when not 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is known. The description adds value by specifying the return payload (structured event data with time, location, attendees, status), which goes beyond the annotations. No contradictions found.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, with the main action front-loaded. Every sentence provides necessary information: what it does and what it returns. No waste or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no output schema, the description adequately explains the return value (structured event data with key fields). Given the simple parameter set and safe annotations, this is sufficient. It could mention edge cases like missing calendar parts, but that's not essential for basic usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers all three parameters (account, mailbox, email_id) with descriptions, achieving 100% coverage. The description does not add parameter-specific meaning, but per the rubric, high schema coverage warrants a baseline score of 3. No additional parameter context is necessary.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: extracting calendar events (ICS/iCalendar) from an email. It uses a specific verb ('Extract') and resource ('calendar events from an email'), distinguishing it from siblings like list_events (which lists existing calendar events) and extract_contacts (which extracts contacts).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The context for use is clear: when you have an email containing calendar data and need structured event information. However, it does not explicitly mention alternatives or state when not to use it. The description implies usage rather than providing direct comparisons to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds the behavioral trait that the original email is quoted below, and notes that the message is optional. The annotations already indicate non-read-only and non-destructive, and the description does not contradict them. It does not detail side effects beyond the quoted content, but with annotations lowering the bar, 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the purpose, and every word earns its place. It is efficient and clear without unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 7 parameters but a 100% schema description, the description is adequately complete for a standard forward operation. It does not cover return values, but with no output schema and the simplicity of the action, this is not a major gap. The lack of explicit alternative guidance is a minor omission.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all parameters are documented in the schema. The description adds minimal extra meaning: 'optional additional message' mirrors the schema's body description, and 'Original email is quoted below' is behavioral rather than parameter-specific. It does not significantly enhance understanding of parameters beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Forward an email to new recipients with optional additional message.' This clearly distinguishes the tool from siblings like send_email and reply_email, and the mention of 'new recipients' and 'optional additional message' adds useful scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context by indicating this is for forwarding an existing email to new recipients, which inherently contrasts with sending a new email or replying. However, it does not explicitly name alternative tools or provide when-not-to-use guidance, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds a valuable behavioral note: 'Does NOT mark emails as seen.' It also discloses the default format behavior ('text' strips HTML), which is useful for agents expecting raw content. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: first states the core action and constraint, then gives a usage rationale, and finally notes behavioral side-effects. Every sentence earns its place, with no redundant filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 100% schema description coverage, readOnly annotations, and no output schema, the description provides sufficient context for a batch-read tool. It could have added a note about the return structure (e.g., object keyed by email ID) but this is already implied by 'full content'. The description is adequate for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the schema already describes each parameter thoroughly (ids, format, account, mailbox, maxLength). The description mentions the 'max 20' limit and the 'text' default, but these are already in the schema. It adds no significant new semantic meaning beyond what the schema provides, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Fetch' and clearly identifies the resource as 'full content of multiple emails' with an explicit max of 20. It distinguishes itself from the sibling tool get_email by highlighting batch operation and from list_emails/search_emails by mentioning 'full content', 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.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states when to use this tool: 'when triaging or summarising several emails' and compares it to calling get_email repeatedly. However, it doesn't mention when not to use it relative to other siblings like search_emails or list_emails, leaving some implicit context gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds behavior beyond the annotations ('readOnlyHint: true, destructiveHint: false') by explicitly stating 'Does NOT mark emails as seen.' This is useful because many email tools inadvertently mark messages as read. It also discloses how maxLength truncates bodies ('A hint shows how many characters remain') and how newestFirst changes the response structure, giving the agent expectations about output behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is composed of four concise sentences that each earn their place: the core purpose, a key side-effect (not marking as seen), format guidance, newestFirst guidance, and a prerequisite. It is front-loaded with the most important information and tightly scoped with no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 6 parameters and no output schema, but the description covers the return concept ('Returns all related messages') and explains key options (format, newestFirst, maxLength). It also references the required prerequisite (get_email). It does not describe response fields or ordering details beyond newestFirst, but for a read-only thread reconstruction tool, this is adequate context given the rich input schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides detailed descriptions for all six parameters (100% coverage), so the description's input-schema value is marginal. The description does add workflow context like 'from get_email' for message_id and 'Ideal for AI triage' for newestFirst, but these are usage hints rather than semantic explanations of parameter values. Per calibration, a baseline of 3 is appropriate when the schema carries the parameter documentation burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Reconstruct a full email conversation thread by following References and In-Reply-To headers' – a specific verb and resource that clearly distinguishes it from siblings like get_email (single message) and get_emails (likely bulk). It also explicitly states the tool's output: 'Returns all related messages.' This is unambiguous and action-oriented.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context, including a prerequisite ('Use get_email first to obtain the message_id') and specific guidance for parameters (`Use format="text" to strip HTML, or format="stripped" to also remove quoted replies`, `Use newestFirst=true to show the most recent message in full`). It also states an ideal use case ('Ideal for AI triage of long threads'), but it does not explicitly say when not to use this tool versus alternatives beyond the get_email prerequisite.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, which covers safety. The description adds useful context about the tool's focus (IMAP IDLE watcher connections) and that it reports recent activity, going beyond what annotations provide. It does not detail output format, but for a read-only status tool this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no redundant words. It conveys the essential purpose and scope efficiently, earning a perfect score for conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only status tool with no output schema, the description is sufficiently complete. It tells the agent what resource is inspected and that recent activity is included. However, it leaves vague what 'status' encompasses (e.g., booleans, counts, timestamps), so it is not perfect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, and the schema coverage is 100% (vacuously). Per the guideline, a baseline of 4 applies when there are no parameters to document. The description does not need to explain parameter meanings.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly specifies the verb 'Get' and the resource 'status of IMAP IDLE watcher connections and recent activity'. It uniquely identifies the tool among siblings, which mostly focus on emails, mailboxes, or calendars, making it distinct as a status/diagnostic tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The usage context is implied: it is a diagnostic tool for inspecting IMAP IDLE watcher connections. However, it does not explicitly state when to use it over related tools like check_health or check_notification_setup, nor does it provide exclusions or alternative recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds the 'Call this first' context, which is more of a usage guideline than a behavioral trait. It does not detail return format, but for a zero-parameter read-only list tool, the basic behavior is self-evident.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: the first delivers the core function, the second adds essential usage guidance. No redundancy or filler; the most important information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple zero-parameter discovery tool, the description covers what it does, when to use it, and hints at the output ('available account names'). Annotations confirm safety. A minor gap is the lack of explicit response structure, but the description sufficiently implies the return value.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema provides full coverage by definition. The description adds the expected output ('account names'), which is useful for setting expectations but not required for parameter understanding. Baseline 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List all configured email accounts' with a specific verb and resource. It also distinguishes itself from sibling tools like list_mailboxes and list_emails by framing it as a discovery step for account names.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The instruction 'Call this first to discover available account names for use with other tools' provides explicit temporal guidance and establishes the tool as a prerequisite. It does not name alternative tools or explicitly state when not to use it, 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description does not contradict this. It adds behavioral context by explaining auto-detection among ProtonMail, Gmail, and IMAP label systems, and discloses the ProtonMail folder prefix behavior. This goes beyond the annotation and helps the agent understand potential platform-specific variations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise but complete, with four short sentences. The first sentence front-loads the core purpose, followed by essential auto-detection details and a practical ProtonMail tip. Every sentence earns its place with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple one-parameter tool with no output schema, the description covers the key behaviors: what it lists, how it auto-detects, and a platform-specific note. It does not detail the exact return format, but for a straightforward list operation this is acceptable. It could be slightly more explicit about output, but overall it is sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (the 'account' parameter is described as 'Account name from list_accounts'). The tool description does not add further meaning to the parameter; it relies on the schema. According to the rubric, a baseline of 3 is appropriate when the schema fully documents parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'List available labels for an email account.' It uses a specific verb ('list') and resource ('labels'), and distinguishes itself from sibling tools like list_mailboxes by focusing on the label system and auto-detection. The ProtonMail note further differentiates this from generic mailbox listing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides context on when to use the tool and how to handle ProtonMail-specific label representation. It explicitly instructs using list_emails with a specific mailbox prefix to find emails with a ProtonMail label. However, it does not explicitly exclude alternatives like list_mailboxes or state when not to use this tool, so it stops short of a full when/when-not guide.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that presets include descriptions and suggested labels, which is useful but doesn't go beyond what a simple list tool obviously returns. No side effects or additional behaviors are disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that conveys the action, scope, and output content without redundancy. Every word adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple no-parameter list tool with read-only annotations, the description is complete: it tells what the tool returns (presets with descriptions and labels). The lack of an output schema is compensated by this explicit mention. Minor details like pagination or ordering are not necessary for such a straightforward operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema is empty. The baseline for 0 params is 4, and the description accurately reflects that no arguments are needed, so no additional parameter semantics are required.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action ('List'), resource ('all available AI triage presets'), and includes output details ('with their descriptions and suggested labels'). This distinguishes it from sibling tools like list_templates and list_labels.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies use when the agent needs to discover available AI triage presets or their labels. It doesn't mention exclusions or alternatives, but the context is sufficiently clear for a read-only listing tool with no parameters.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructive behavior, but the description adds valuable context by explaining the exact sequence: fetch, send via SMTP, then delete. This provides transparency beyond the annotation without contradicting it, though it does not cover failure cases or partial outcomes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with the primary purpose, followed by the process and a usage hint. Every sentence earns its place, with no redundant details or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple action, full schema coverage, and no output schema, the description is largely complete. It explains the workflow and provides a hint for finding IDs. Minor gaps include error handling or return behavior, but these are not critical for a straightforward send-and-delete operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with each parameter already documented. The description adds a useful hint about using list_emails to get draft IDs, but otherwise does not deepen parameter understanding beyond the schema. This meets the baseline for high schema coverage with marginal extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool sends an existing draft email and removes it from Drafts, with a specific verb and resource. It distinguishes itself from siblings like send_email by focusing on existing drafts, and the process (fetched, sent, deleted) leaves no ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly tells users to use list_emails with the Drafts mailbox to find draft IDs, which is actionable usage guidance. It implicitly excludes using send_email for new emails, but does not explicitly contrast with alternatives. However, the context is clear enough for an agent to know when to choose this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (readOnlyHint=true, destructiveHint=false), the description discloses that the tool returns base64-encoded content and has a 5MB file size limit. This is valuable behavioral information that helps the agent set expectations. It does not mention error handling or auth requirements, but the core behavior is 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences that front-load the purpose, then add usage guidance and return format. Every sentence is informative and no words are wasted. It earns a perfect score for efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (4 params, no output schema), and the description covers the essential aspects: what it does, how to prepare (use get_email), what it returns (base64), and a key constraint (≤5MB). The annotations cover safety. For its complexity, the description is fully complete and leaves no significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides 100% parameter coverage, including descriptions for all four parameters. The description adds minimal extra meaning beyond stating 'by filename', which is already captured in the schema's filename description. Since the schema does the heavy lifting, a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Download an email attachment by filename.' It uses a specific verb and resource, and it distinguishes itself from sibling tools by focusing on attachment downloads. The description also provides a prerequisite step ('First use get_email'), which clarifies its role in the workflow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear usage context by instructing to first use get_email to retrieve attachment filenames. This establishes a recommended sequence and differentiates from get_email itself. However, it does not explicitly mention when not to use this tool or list alternative tools, but given the sibling set, no direct alternative exists.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds useful behavioral context: it processes 'recent email headers', returns 'unique' contacts, and sorts them 'by frequency', which goes beyond the annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the primary action and result, then a brief use-case statement. Every sentence earns its place with concise, useful information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, with no output schema. The description explains the output format ('contacts sorted by frequency') and the scanning scope ('recent email headers'). Combined with the schema, this gives an agent everything needed to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with each parameter (limit, account, mailbox) already described. The description mentions 'recent email headers' and frequency sorting, but does not add material semantic detail about the parameters beyond what the schema provides. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Extract') and resource ('unique contacts from recent email headers'), and clearly states the output ('Return contacts sorted by frequency'). This distinguishes it from sibling tools like 'extract_calendar'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear use cases ('Useful for finding frequent correspondents or building an address book'), giving context for when to use the tool. It doesn't explicitly mention when not to use it, but no alternative contact-extraction sibling exists, so the context is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavior: default to incomplete reminders, filtering options, and the exact return fields. This goes beyond annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Five short, information-dense sentences. Front-loaded with purpose, then filters, default behavior, use cases, and return fields. Every sentence earns its place with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list tool without an output schema, the description is thorough: it explains default behavior, optional filters, return fields, and use cases. Combined with complete schema annotations and read-only hints, the agent has everything needed to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers all 4 parameters with complete descriptions (100% coverage), so baseline is 3. The description adds context by mentioning 'Search by title or list name' and 'By default only shows incomplete reminders,' which maps to title/list_name/include_completed, but it doesn't provide significantly new parameter semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('List') and resource ('reminders from macOS Reminders.app') with optional filters. Clearly distinguishes from sibling tools like create_reminder by focusing on read-only listing. Also specifies the returned fields, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear use cases: 'Use to check for existing reminders before creating new ones, or to verify a recently added reminder.' This implicitly differentiates from create_reminder and other tools. While it doesn't list exclusions, the context is sufficient for an agent to know when to apply this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare idempotentHint=true, but the description adds specific behavioral context by explaining that marking an already-read email as read is a no-op. This goes beyond structured data and clarifies the idempotency semantics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with no filler, front-loading the action and adding only the useful idempotency detail. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple flag mutation tool with full schema coverage and idempotency annotations, the description covers all essential information. No output schema exists, and return values are not needed for this operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with each parameter described in detail including the action enum. The description's mention of 'read/unread, flag/unflag' mirrors the schema's action values without adding new parameter semantics, so the baseline score is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool changes email flags (read/unread, flag/unflag), which is a specific verb+resource combination. It distinguishes itself from sibling tools like move_email or delete_email by focusing solely on flag modifications.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes it obvious when to use this tool—whenever email flags need to be modified. It doesn't explicitly mention alternatives or exclusion criteria, but the tool's narrow scope makes misuse unlikely and no alternative flag tool exists among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=false and destructiveHint=false, so the description carries additional burden. It explicitly discloses that changes take effect immediately, that save=true persists to config.toml, and that omitted fields are left unchanged. This goes beyond the annotations by explaining the runtime vs persistent behavior, which is valuable context 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each adding distinct value: purpose, immediate effect, save behavior, and partial updates. Front-loaded with the main action. No fluff, perfectly sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 6 parameters and no output schema, the description covers the essential context: runtime vs persisted changes, immediate effect, and partial update behavior. It lacks explicit mention of return values or configuration read alternatives, but these are not critical given the schema richness. Overall, sufficiently complete for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% parameter description coverage, so baseline is 3. The description adds value by stating 'Omit any field to leave it unchanged', which applies to all parameters and clarifies partial update semantics. It also reinforces the save parameter's behavior, aligning with its schema description. This exceeds the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Update' with the resource 'alert/notification settings', clearly indicating the tool's function. This distinguishes it from sibling tools like test_notification (which tests notifications) and get_hooks_config (which reads configuration). No ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear context for usage: changes take effect immediately, save=true persists to config, and omitting fields leaves them unchanged. While it doesn't explicitly name alternatives or state when not to use this tool, the guidance is sufficient for basic operation and implies that this is the go-to tool for runtime configuration updates.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (destructiveHint=true), the description adds valuable context: default moves to Trash, permanent deletion is irreversible, and the mailbox must be a real folder. This helps the agent understand consequences and prerequisites.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with the core action, and each sentence adds essential information without redundancy. Perfectly sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description covers key operational details: default behavior, permanent option, folder requirement, and prerequisite tool. It lacks return-value info but that's typically not critical for delete operations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers all parameters with descriptions (100% coverage), so baseline is 3. The description adds meaning to 'permanent' (irreversible) and 'mailbox' (must be real folder), enhancing understanding beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Delete' and resource 'email', and distinguishes from sibling tools like move_email and delete_mailbox by specifying default Trash behavior and permanent deletion option.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear guidance on when to use permanent=true vs default, and explicitly advises using find_email_folder first when dealing with virtual folders. While it doesn't explicitly compare to move_email, the trash behavior implies an alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true, but the description adds valuable platform-specific context: the difference between ProtonMail folder deletion and IMAP keyword limitations. This goes beyond the annotation by explaining real-world behavior and constraints, though it doesn't describe error conditions or return values.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at two sentences, with the primary action front-loaded ('Delete a label') followed by necessary edge-case clarification. Every sentence contributes useful information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive tool with no output schema, the description adequately covers what the tool does and when to use it, including a key platform caveat. It could mention success/failure behavior or return value, but this is not essential given the clarity of the description and annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage of both parameters (name and account) with clear descriptions. The tool description does not add additional parameter-level detail, so it correctly relies on the schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Delete a label' and distinguishes between ProtonMail (deletes label folder) and standard IMAP keywords (cannot be deleted server-wide). It differentiates from sibling tools, especially remove_label, by explaining when each is appropriate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit guidance is provided: 'For ProtonMail, deletes the label folder. For standard IMAP keywords, labels cannot be deleted server-wide — use remove_label on individual emails.' This tells the agent exactly when to use this tool and when to use an alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, and the description aligns with this by describing a read-only listing operation. It adds valuable behavioral details beyond the annotations: paginated results, metadata (with icons), and the ProtonMail-specific behavior where labels are represented as IMAP folders — a non-obvious nuance that helps agents avoid pitfalls.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each purposeful: the first states the core function and return type, the second points to a sibling for a specific need, and the third offers a platform-specific tip. No filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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 covers the essential aspects: listing with filters, paginated results, metadata, and a critical platform-specific caveat. It doesn't fully address differentiation from search_emails or output structure, but the schema and sibling names fill those gaps. It is sufficiently complete for an agent to decide when and how to use it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 100% of parameters, so baseline is 3. The description adds extra meaning by providing a concrete usage example for the mailbox parameter (mailbox='Labels/X'), showing how ProtonMail labels map to folders. This goes beyond the schema's generic 'Mailbox path (default: INBOX)' and enriches understanding of the filter behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'List emails in a mailbox with optional filters' — a specific verb and resource that immediately conveys the tool's function. It also distinguishes itself from related tools by directing users to 'get_email' for full body content, and the mention of metadata (read/unread, flagged, replied, attachments, labels) adds further scope clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance: use get_email for full body content, and for ProtonMail labels use list_labels then list_emails with mailbox='Labels/X'. This gives clear context for when to use the tool versus alternatives, though it doesn't explicitly contrast with search_emails or other sibling list tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare this as a safe read-only operation (readOnlyHint=true, destructiveHint=false). The description adds valuable context beyond annotations by specifying the exact filesystem location (~/.config/email-mcp/templates/) and the placeholder syntax ({{variable}}), which helps the agent know what to expect when invoking the tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, dense sentence that conveys both the action and the relevant details (location, format) without any wasted words. It is front-loaded with the core purpose and then provides supporting context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with no output schema, the description sufficiently covers what the tool does and what the templates are. It could potentially describe the return format (e.g., template names or paths), but the given details are adequate for an agent to select and call the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the description provides all needed context about the data source. With 0 parameters, the schema already covers everything; the description's mention of the template location adds meaning beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'list' with the resource 'email templates', clearly distinguishing this from sibling tools like list_accounts or list_mailboxes. It also specifies the scope ('all available') and adds detail about the template format, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies this tool is used to discover available templates (e.g., before applying one), but it does not explicitly mention alternatives or when not to use it. The context about TOML files and placeholders provides useful background that helps the agent understand the tool's role.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the tool as non-readonly and non-destructive, so the bar is lower. The description adds useful lifecycle context—'compose over time' and how drafts are later sent or listed—without contradicting annotations. It doesn't mention side effects like overwriting, but the added workflow detail is valuable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences with a clear front-loaded purpose, followed by workflow and viewing guidance. No filler or redundancy; every sentence contributes to tool understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 8 parameters and no output schema, the description provides the essential workflow context (save, send, view drafts) that an agent needs. It doesn't explain return values, but the lifecycle and intent are sufficiently covered for a draft-saving tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% parameter description coverage, so the schema carries the burden. The description doesn't introduce new parameter details, but it implies the draft workflow (e.g., saving without sending), which is consistent with the schema's note that 'to' can be empty for drafts. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action and resource: 'Save an email draft to the Drafts folder.' It distinguishes from sibling tools by explicitly referencing send_draft for sending and list_emails for viewing drafts, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear when-to-use guidance: 'Compose over time, then use send_draft to send it.' It also names the alternative for viewing drafts ('Use list_emails with the Drafts mailbox'), offering explicit contextual direction beyond just stating the action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes beyond the annotations (readOnlyHint=true, destructiveHint=false) by explaining that it verifies specific macOS Calendar.app access and that it returns 'granted status and step-by-step setup instructions if access is denied.' This adds valuable behavioral context about the response and prerequisites.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at two sentences, with no redundant information. It front-loads the core purpose and then adds necessary platform-specific details without any filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple no-parameter check tool with no output schema, the description is fully complete. It covers what the tool does, platform specifics, permission requirements, and what it returns (status + setup instructions). Combined with annotations confirming safety, there are no gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and an empty input schema, so there is nothing to add. Baseline for 0 params is 4, and the description appropriately focuses on behavior rather than parameter details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Check') and resource ('local calendar accessibility'). It also distinguishes itself from sibling calendar tools (like list_calendars, add_to_calendar) by focusing specifically on permission/access verification, not calendar operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool (to check if calendar is accessible) and mentions the platform-specific requirement (macOS permission). It doesn't explicitly name alternatives or say when not to use it, but the context is strong enough that an agent would know this is a pre-flight permission check rather than a calendar data operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes beyond the destructiveHint annotation by specifying 'ALL its contents' and 'This cannot be undone,' which details the full scope of destruction. It also advises verification, adding practical behavioral context not present in the annotations. No contradiction exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, front-loaded with a prominent warning emoji, and delivers maximum information with zero wasted words. It efficiently conveys irreversibility, scope, and a verification step.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 2-parameter destructive operation, the description is complete: it covers the action, irreversibility, scope, and prerequisite verification. Annotations cover the safety profile, and the schema covers parameters. No output schema is needed, and no critical information is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters already well-described in the schema (e.g., path explains 'all emails inside will be lost'). The description itself adds no additional parameter-level detail, so the baseline of 3 applies as the schema carries the burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action: 'Permanently delete a mailbox and ALL its contents.' This distinguishes it from sibling tools like delete_email and delete_label, which operate on different resources. The verb 'delete' plus resource 'mailbox' is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a concrete safety guideline: 'Use list_mailboxes to verify the folder path.' This tells the agent when and how to prepare for using the tool. However, it does not explicitly mention alternatives or when not to use it, though the destructive nature makes the usage context clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes beyond the readOnlyHint annotation by explaining the return behavior ('Returns the real folder path to use as sourceMailbox') and its role in subsequent operations. It does not contradict the annotation and adds useful context about the tool's purpose and output, though it does not detail error cases or other behavioral nuances.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose, and every sentence earns its place. It states what the tool does, when it's needed, and what it returns, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple read-only utility with a clear purpose, complete parameter schema, and no output schema. The description covers what the tool does, when to use it, and the nature of its return value, making it fully self-contained for an agent to select and invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides 100% coverage with meaningful descriptions for all three parameters, so the baseline is 3. The description adds a relationship note: the returned path is used as sourceMailbox for move/delete, which is helpful but does not substantially alter the parameter understanding beyond what the schema already offers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Find which real mailbox folder(s) an email belongs to.' It uses a specific verb ('Find') and resource ('real mailbox folder(s)'), and distinguishes it from siblings by noting it is a required prerequisite for move_email and delete_email when the email is in a virtual folder. This is highly specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use the tool: 'Required before move_email or delete_email when the email was found in a virtual folder (e.g., "All Mail", "Starred").' This gives clear context and includes examples, making it evident when this tool is necessary and when it might not be (though not explicitly stated, the condition is clear).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint true and destructiveHint false. The description adds useful context about local-only calendars and platform scope (macOS/Linux), which goes beyond the annotations. It doesn't describe return format, but for a zero-parameter list tool that's a minor omission.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences front-load the primary action and then provide actionable downstream guidance. Every word earns its place; no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple zero-parameter list tool, the description is fully complete: it states what is listed, platform specificity, and how to use the results. The pointer to add_to_calendar adds pragmatic context. No output schema exists, but the return values (calendar names) are obvious from the description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description adds no parameter details (properly, as none exist), and the empty input schema is fully self-documenting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists all available local calendars, specifying the scope as macOS Calendar.app / Linux default. This distinguishes it from sibling tools like list_events or list_accounts, and mentions the practical use of returned names with add_to_calendar.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides explicit guidance on when to use the tool: to obtain calendar names for targeting a specific calendar in add_to_calendar. However, it does not explicitly mention when not to use it or compare with alternative list tools, so it's slightly below a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate a non-read-only, non-destructive, idempotent operation. The description adds a meaningful constraint about virtual folders being invalid sources, which is behavioral context beyond the annotations. It doesn't detail failure modes, but the added constraint is valuable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first states the core purpose, and the second provides a crucial constraint and prerequisite. Every word earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple move operation with all parameters documented in the schema and safety traits covered by annotations, the description adds the essential caveat about virtual folders and the find_email_folder prerequisite. It is complete enough without an output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover all four parameters, but the description enhances the meaning of sourceMailbox by clarifying that it must be a real folder, not virtual. This is additional semantic value beyond the structured schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action with a specific verb ('Move') and resource ('an email') to a destination ('a different mailbox folder'). It distinguishes from sibling tools like delete_email or mark_email by focusing on relocation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: sourceMailbox must be a real folder, and it names find_email_folder as a prerequisite when the email was discovered in a virtual folder. This gives clear contextual direction, though it doesn't mention alternatives like bulk_action for multiple moves.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds context beyond the sparse annotations (readOnlyHint=false, destructiveHint=false) by explaining the purpose is to verify OS permissions and that it sends a test notification. However, it does not disclose potential side effects like whether a notification visibly appears to the user or any failure modes if permissions are missing, but this is largely implied.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loaded with the main action and followed by a useful cross-reference. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter and no output schema, the description fully covers what the tool does, why to use it, and how to proceed if issues arise. It is complete for an agent to select and invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with the only parameter 'sound' clearly described as 'Include a sound alert in the test notification'. The tool description adds no parameter-specific meaning beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Send a test desktop notification to verify that OS permissions are correctly configured.' It uses a specific verb ('send') and resource ('test desktop notification'), and distinguishes it from the diagnostic sibling 'check_notification_setup'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides usage guidance: 'Use check_notification_setup first to diagnose any issues.' This tells the agent when to use this tool (after checking setup) and names the alternative tool for diagnostics.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false. The description goes further by explaining the IMAP BODY.PEEK mechanism and explicitly stating that reading does NOT mark emails as seen unless markRead is set. This fully discloses side effects and goes beyond the annotation baseline.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: the first sentence states the core purpose and key non-destructive trait, followed by three targeted sentences on parameter usage. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With a 6-parameter schema and no output schema, the description explains behavioral aspects and usage choices well. It could be more explicit about the exact return structure (e.g., headers vs. body), but the phrase 'full content' plus the maxLength hint provides a sufficient mental model for most use cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so all parameters are already described. The description adds valuable usage context—such as using maxLength for large emails and explaining that markRead is only for explicit read-marking—thereby enriching parameter semantics beyond the schema's basic descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Get the full content of a specific email by ID', clearly stating a specific verb, resource, and scope. It also emphasizes the non-destructive nature, which helps differentiate it from other email operations like mark_email or get_emails.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear, actionable guidance on when to use format, maxLength, and markRead parameters: 'Use format="text"...', 'Use maxLength to cap the body size...', 'Set markRead=true only when...'. It does not explicitly list alternative sibling tools, but the parameter usage context is strong.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint and destructiveHint, but the description adds valuable behavioral context: it does not mark the email as seen and is cheaper than fetching a full email. This goes beyond annotation hints to clarify side effects and performance.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three succinct sentences front-load the primary purpose, then add usage guidance and a side-effect caveat. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a low-complexity read tool with fully specified params and good annotations, the description covers purpose, usage, side-effect nuance, and alternative. The absence of an output schema is mitigated by naming the returned state dimensions (read/flag/label).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All three parameters are described in the schema with clear provenance (account from list_accounts, emailId from list_emails/search_emails, mailbox path default). The description doesn't add new parameter-level details beyond what the schema already provides, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves email state metadata (read/flag/label) without fetching the body, differentiating it from get_email. The verb 'Get' and specific resource target make the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly recommends using this tool over get_email when only state is needed, and mentions confirming mark_email results. This provides clear when-to-use guidance and names an alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![email-mcp MCP server](https://glama.ai/mcp/servers/123jixinyu/email-mcp/badges/card.svg)](https://glama.ai/mcp/servers/123jixinyu/email-mcp)

Score Badge

Copy to your README.md:

[![email-mcp MCP server](https://glama.ai/mcp/servers/123jixinyu/email-mcp/badges/score.svg)](https://glama.ai/mcp/servers/123jixinyu/email-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/123jixinyu/email-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server