AgentMail

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation5/5
Every tool has a clearly distinct purpose targeting specific resources and actions. For example, createInbox vs. getInbox vs. listInboxes are distinct operations on inboxes, and getMessage vs. sendMessage vs. replyToMessage handle different message interactions. There is no ambiguity or overlap in functionality.
Naming Consistency4/5
The naming follows a consistent verb_noun pattern throughout, such as createInbox, getInbox, listInboxes, sendMessage, and replyToMessage. However, there is a minor deviation with getAttachment (using 'get' instead of a more specific verb like 'download' or 'retrieve'), but overall the pattern is predictable and readable.
Tool Count5/5
With 10 tools, this server is well-scoped for an email/communication domain. Each tool earns its place by covering essential operations like inbox management, message handling, and threading, without being overly sparse or bloated. The count aligns well with typical MCP server ranges.
Completeness4/5
The tool surface provides strong coverage for core email workflows, including CRUD operations for inboxes, messages, and threads, as well as actions like sending and replying. A minor gap is the lack of tools for deleting or updating messages/inboxes, but agents can work around this, and the set supports most common use cases effectively.
Average 2.1/5 across 10 of 10 tools scored. Lowest: 1.5/5.
See the Tool Scores section below for per-tool breakdowns.
- 1 of 7 community issues answered or closed in the last 6 months
- 51 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 passing
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
Add a README.md file to help users understand your server.
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.
Add a glama.json file to provide metadata about your server.
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

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure but offers none. It doesn't indicate whether this is a read or write operation, what permissions are required, how replies are formatted or delivered, or any side effects. This leaves critical behavioral traits completely undocumented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at just three words, which could be efficient if it were informative. However, it's under-specified rather than appropriately concise—it wastes no words but fails to convey necessary information, making this borderline between minimal and inadequate.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a messaging tool with 5 parameters, no annotations, no output schema, and 0% schema description coverage, the description is completely inadequate. It doesn't explain what the tool does beyond the name, how to use it, what parameters mean, or what to expect in return, failing to provide essential context for effective tool invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides no information about parameters, while the input schema has 0% description coverage (titles only, no descriptions). With 5 parameters (3 required) and no parameter semantics explained in either the schema or description, the agent lacks essential context for what each parameter means and how to use them.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Reply to a message' is a tautology that restates the tool name 'replyToMessage' without adding specificity. It mentions the verb 'reply' and resource 'message' but fails to distinguish this from sibling tools like 'sendMessage' or provide any details about what replying entails in this context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/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 doesn't mention prerequisites like needing an existing message to reply to, nor does it differentiate from 'sendMessage' or other messaging tools in the sibling list, leaving the agent with no usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden but fails to disclose behavioral traits. It does not indicate if creation is idempotent, requires authentication, has rate limits, or what happens on success/failure, leaving critical operational details unspecified for a mutation 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 extremely concise with a single sentence 'Create a new inbox', which is front-loaded and wastes no words. However, this brevity comes at the cost of under-specification, but as per scoring rules, it earns full marks for efficiency in structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity as a mutation with no annotations, 0% schema coverage, no output schema, and three parameters, the description is completely inadequate. It lacks details on behavior, parameters, outputs, and context, failing to provide a minimal viable understanding for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, with three parameters (display_name, domain, username) undocumented in the schema. The description adds no meaning beyond the tool name, offering no explanation of what these parameters do, their formats, or how they affect inbox creation, failing to compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Create a new inbox' restates the tool name 'createInbox' with minimal elaboration, making it tautological. It specifies the verb 'create' and resource 'inbox' but lacks detail on what an inbox is or how it differs from siblings like 'listInboxes' or 'getInbox', leaving purpose vague beyond the obvious.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites, such as whether an inbox must be created before using tools like 'sendMessage', or when to choose this over other inbox-related tools, offering no context for decision-making.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. 'List messages' reveals nothing about permissions, rate limits, pagination behavior, or response format. It fails to describe what 'list' entails operationally.
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 with two words, but this brevity results in under-specification rather than effective communication. Every word earns its place, but the description is too minimal to be helpful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 parameters with 0% schema coverage, no annotations, and no output schema, the description is completely inadequate. It provides no context about the tool's behavior, parameters, or output, leaving critical gaps for agent understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning parameters (inbox_id, limit, offset) are undocumented in the schema. The description adds no parameter information beyond what the schema provides, offering no clarification on usage, constraints, or relationships between parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'List messages' is a tautology that restates the tool name without adding meaningful context. It specifies the verb 'list' and resource 'messages' but lacks any distinguishing details about scope, format, or relationship to sibling tools like listThreads or getMessage.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. With siblings like listThreads, getMessage, and getThread available, the description offers no context about selection criteria, prerequisites, or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Send a message' implies a write operation but reveals nothing about permissions required, whether the message is queued or sent immediately, rate limits, error conditions, or what happens upon success. For a mutation tool with 7 parameters and no annotation coverage, this is completely inadequate.
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 just two words, with zero wasted language. While this brevity contributes to under-specification in other dimensions, from a pure conciseness perspective, it's maximally efficient with every word earning its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 7 parameters, no annotations, no output schema, and 0% schema description coverage, the description is completely inadequate. It doesn't explain what the tool does beyond the name, provides no parameter guidance, offers no behavioral context, and gives no indication of return values. This leaves the agent with insufficient information to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning none of the 7 parameters have descriptions in the schema. The tool description provides no information about parameters, not even mentioning key fields like 'to', 'subject', or 'inbox_id'. This leaves all parameter meanings undocumented, failing to compensate for the schema's lack of coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Send a message' is a tautology that merely restates the tool name without specifying what type of message or to what system. It lacks distinction from sibling tools like 'replyToMessage' and doesn't clarify if this is for email, chat, or another messaging system. While the verb 'send' is clear, the resource 'message' is too vague given the context of other email-related tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'replyToMessage'. The description doesn't mention prerequisites, context, or exclusions. Given the sibling tools include various email-related functions, this omission leaves the agent without direction on selecting the appropriate tool for sending a new message versus replying.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get inbox by ID' only indicates a read operation without specifying permissions, rate limits, error handling, or what is returned (e.g., inbox metadata, messages, or status). This is inadequate for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with a single phrase 'Get inbox by ID', which is front-loaded and wastes no words. However, this conciseness comes at the cost of under-specification, but as per scoring rules, it earns high marks for brevity and structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, 0% schema coverage, no output schema, and sibling tools like 'listInboxes' and 'getMessage', the description is incomplete. It does not explain what an 'inbox' entails, how to use the ID, or what the tool returns, making it inadequate for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, with one parameter 'inbox_id' undocumented in both schema and description. The description 'Get inbox by ID' implies the parameter is an identifier but adds no meaning beyond the schema's title 'Inbox Id', failing to compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get inbox by ID' restates the tool name 'getInbox' with minimal elaboration, making it tautological. It specifies a verb ('Get') and resource ('inbox'), but lacks specificity about what 'Get' entails (e.g., retrieve metadata, messages, or details) and does not differentiate from siblings like 'listInboxes' or 'getMessage'.
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?
No guidance is provided on when to use this tool versus alternatives. For example, it does not clarify if this is for retrieving a specific inbox's details versus listing all inboxes with 'listInboxes' or fetching messages within it with 'getMessage', leaving usage context implied but undefined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden but offers minimal behavioral information. It doesn't disclose whether this is a read-only operation, what format the attachment is returned in, error conditions, authentication needs, or rate limits. The description is too basic to inform the agent about how the tool behaves.
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 with just four words, front-loaded and zero waste. It efficiently states the core purpose without unnecessary elaboration, though this brevity contributes to gaps in other dimensions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (3 required parameters, no annotations, no output schema), the description is completely inadequate. It doesn't explain what an attachment is in this system, how to use the IDs, what the tool returns, or any error handling. For a tool with multiple required identifiers and no structured documentation, this leaves the agent with insufficient context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning none of the three required parameters (attachment_id, inbox_id, message_id) are documented in the schema. The description adds no meaning beyond the tool name, failing to explain what these IDs are, how to obtain them, or their relationships. This leaves parameters completely undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get attachment by ID' clearly states the action (get) and resource (attachment), but it's vague about scope and doesn't differentiate from potential siblings. It doesn't specify whether this retrieves metadata, content, or both, nor does it mention what an 'attachment' represents in this context.
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?
No guidance is provided on when to use this tool versus alternatives. With sibling tools like getMessage and getThread, it's unclear if attachments are accessible through those tools or if this is the exclusive method. No prerequisites or context about required IDs are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure but offers minimal information. It doesn't mention whether this is a read-only operation, if it requires authentication, what the return format looks like, or any rate limits. The description fails to compensate for the lack of 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 a single, efficient sentence with no wasted words. It's appropriately sized and front-loaded with the core purpose, though it could benefit from additional context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (3 parameters, 0% schema coverage, no annotations, no output schema), the description is incomplete. It doesn't explain the tool's behavior, return values, or parameter details beyond the basic filter, making it inadequate for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate but only partially does so. It mentions 'by inbox ID' which clarifies the required inbox_id parameter, but doesn't explain limit or offset (pagination parameters) or their default behaviors. This leaves two of three parameters inadequately documented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'List threads by inbox ID' clearly states the action (list) and resource (threads), but it's vague about scope and doesn't differentiate from sibling tools like listMessages or listInboxes. It specifies the primary filter (inbox_id) but lacks detail about what 'list' entails.
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?
No guidance is provided on when to use this tool versus alternatives like listMessages (which might list messages across threads) or getThread (which retrieves a single thread). The description implies usage with an inbox_id but doesn't specify prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states the basic operation. It doesn't disclose whether this is a read-only operation, what permissions are required, whether it returns full message content or metadata, error conditions, or rate limits. 'Get' implies retrieval but lacks behavioral details needed for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at just three words, front-loading the core purpose with zero wasted text. Every word earns its place, though this conciseness comes at the expense of completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter tool with no annotations, 0% schema coverage, and no output schema, the description is inadequate. It doesn't explain what constitutes a valid message ID, how inboxes relate to messages, what data is returned, or error scenarios. The minimal description leaves too many gaps for reliable tool invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage for both parameters, the description provides no parameter information beyond what's implied by the tool name. It doesn't explain what 'inbox_id' and 'message_id' represent, their format, or how they relate to each other. The description fails to compensate for the complete lack of schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get message by ID' clearly states the verb 'Get' and resource 'message', but it's vague about scope and doesn't differentiate from sibling tools like 'getThread' or 'listMessages'. It specifies retrieval by ID but lacks context about what a 'message' represents in this system.
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?
No guidance is provided about when to use this tool versus alternatives like 'getThread' (for thread-level messages) or 'listMessages' (for multiple messages). The description implies it's for retrieving a single message by ID, but doesn't mention prerequisites like needing an inbox_id or when this is the appropriate retrieval method.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states the basic action without disclosing behavioral traits such as read-only nature, error handling, permissions needed, or response format. It lacks details on what 'get' involves beyond the minimal statement.
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 with zero waste—just four words. It's front-loaded and to the point, though this brevity contributes to gaps in other dimensions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and low schema coverage, the description is incomplete. It doesn't cover what the tool returns, error conditions, or how it fits with sibling tools, making it inadequate for a tool with two required parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate but adds no meaning beyond the schema. It mentions 'by ID' which implies thread_id, but doesn't explain inbox_id or the relationship between parameters, leaving semantics unclear.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Get thread by ID' clearly states the action (get) and resource (thread), but it's vague about what 'get' entails (retrieve details, fetch metadata, etc.) and doesn't differentiate from siblings like 'getMessage' or 'listThreads'. It's functional but lacks specificity.
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?
No guidance is provided on when to use this tool versus alternatives like 'listThreads' or 'getMessage', nor does it mention prerequisites (e.g., needing an inbox_id and thread_id). The description assumes context without explicit instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. 'List all inboxes' implies a read-only operation, but it doesn't disclose behavioral traits like pagination behavior (implied by limit/offset parameters), authentication needs, rate limits, or what 'all inboxes' entails (e.g., user-specific vs. global). This leaves significant gaps for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with just three words, front-loaded with the core action. There's no wasted language, though this conciseness comes at the cost of completeness. Every word earns its place by stating the essential purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 2 parameters with 0% schema coverage, no annotations, and no output schema, the description is incomplete. It doesn't explain parameter usage, return values, or behavioral constraints. For a list operation with pagination parameters, this minimal description leaves too much undefined for reliable tool invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It mentions no parameters at all, failing to explain what 'limit' and 'offset' do (e.g., for pagination) or their default values. This leaves two undocumented parameters, making it hard for an agent to use them correctly.
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 verb ('List') and resource ('all inboxes'), making the purpose immediately understandable. It distinguishes from siblings like 'getInbox' (singular) and 'createInbox', though it doesn't explicitly mention how it differs from other list tools like 'listMessages' or 'listThreads'.
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?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, context for listing inboxes, or when to choose this over other tools like 'getInbox' for specific inbox details. The agent must infer usage from the name alone.
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:

[![agentmail-toolkit MCP server](https://glama.ai/mcp/servers/agentmail-to/agentmail-toolkit/badges/card.svg)](https://glama.ai/mcp/servers/agentmail-to/agentmail-toolkit)

Score Badge

Copy to your README.md:

[![agentmail-toolkit MCP server](https://glama.ai/mcp/servers/agentmail-to/agentmail-toolkit/badges/score.svg)](https://glama.ai/mcp/servers/agentmail-to/agentmail-toolkit)

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/agentmail-to/agentmail-toolkit'

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