# AgentMail MCP for AI Agents MCP

> AgentMail gives your AI agents their own functional email inbox, letting them read, write, and manage messages like any human user. Stop building complex custom integrations; this MCP provides native tools for creating inboxes, scanning conversation threads, sending new emails, replying contextually, and even processing attachments automatically. It's the backbone for deploying autonomous communication systems.

## Overview
- **Category:** productivity
- **Price:** Free
- **Tags:** email-api, inbox-automation, message-threading, programmable-email, agent-communication

## Description

AgentMail lets you grant your AI agent a real email identity. Instead of relying on brittle API wrappers or complex webhooks, this MCP gives your client direct access to functional inbox management. You can use it to create dedicated inboxes for specific teams, scan active conversation threads, and send brand new messages straight out the gate. When an incoming email hits, your agent doesn't just see the subject line; it processes attachments and reads the full message context automatically.

If you're building agents that need to interact with people—whether for customer support or sales outreach—this MCP makes it straightforward. You manage everything through Vinkius, connecting once from any compatible client, and immediately gain the ability to follow up on leads, monitor replies, and draft thoughtful responses autonomously. It’s about giving your AI reliable communication capabilities.

## Tools

### list_inboxes
Retrieves a list of all available inboxes associated with your API key, showing their IDs and email addresses.

### get_inbox
Fetches detailed information about a single inbox using its unique ID.

### create_inbox
Sets up and activates a brand new, dedicated email inbox for your agent, optionally linking it to a custom domain.

### delete_inbox
Deactivates and deletes an entire inbox by its ID, warning that all contained emails will be lost.

### list_threads
Gets a summary list of active conversation threads within a specified inbox, including subject lines and previews.

### get_thread
Reads the entire historical message content for a specific conversation thread ID.

### get_attachment
Downloads or reads the raw data of a file attached to an incoming email message.

### send_message
Composes and sends a completely new, standalone email from your agent's designated inbox.

### reply_to_message
Drafts and sends a reply to an existing conversation thread while maintaining the original message history.

### forward_message
Sends an existing email to a different recipient, with the option of adding custom text before sending.

### update_message
Changes the metadata status of a message, such as marking it as read or archived.

## Prompt Examples

**Prompt:** 
```
Check my main support inbox for any unread inquiries from today.
```

**Response:** 
```
**Support Inbox Summary**
*   **Client A (Inquiry):** Needs a quote for 50 units. *Unread.*
*   **Marketing Team:** General announcement regarding Q3 changes. *Read.*
*   **Prospect Z:** Asking about integration specs. *Unread.* 

You have 2 unread threads, including an urgent inquiry from Client A.
```

**Prompt:** 
```
Can you reply to Prospect Z about the specs and attach the latest pricing sheet?
```

**Response:** 
```
✅ Success. I replied directly to Prospect Z's thread, confirming we can meet their integration needs. The email includes the 'Pricing_Q3_2024.pdf' attachment as requested.
```

**Prompt:** 
```
List all inboxes and delete the old 'test' inbox.
```

**Response:** 
```
Here are your current inboxes:
*   `support-team@company.com` (Active)
*   `billing-dept@company.com` (Active)
*   `test-agent@company.com` (Inactive/Empty)

I have successfully deleted the `test-agent@company.com` inbox, and all associated data is purged.
```

## Capabilities

### Manage multiple agent inboxes
Create, list, or delete dedicated email addresses so your agent can operate within specific departmental silos.

### Scan and retrieve conversation threads
List all active conversations inside a given inbox and read the full history of any thread to get complete context.

### Send new messages or replies
Draft and send brand new emails, or reply directly within an existing conversation thread while preserving message history.

### Process attached files from mail
Automatically download and read any file (like PDFs or images) that was attached to an incoming email.

### Forward emails with context
Take an existing message and forward it, optionally adding your own explanatory text for the recipient.

## Use Cases

### Triage high-volume customer support emails
A client receives 50 new support tickets daily. Instead of manually checking each one, their agent uses list threads to scan all unread conversations, identifies the core issue in a thread, and drafts an initial response using reply to message.

### Conduct autonomous sales follow-ups
A prospect signs up for a demo. The agent waits 48 hours, uses send message to send a personalized follow-up email with attached pricing info (via get attachment), and monitors the response using list threads.

### Process internal department communications
An employee needs to share a document but forgets who has it. The agent uses get thread to pull all conversation history, finds the relevant file via get attachment, and forwards it to the right person using forward message.

### Onboard new departmental accounts
The company launches a new product line requiring dedicated communication. The agent first calls create inbox for 'product-beta@company.com' and then sets up automated monitoring on that specific inbox.

## Benefits

- Instead of writing multiple API calls just to get the thread context, you can use list threads and get thread. This gives your agent a single, clean view of all past interactions.
- Need to send an initial outreach? Use send message to draft brand new emails without needing any existing conversation data. It's pure automation power.
- Never miss a detail again. By using get attachment, your agent can automatically extract and process files attached to incoming messages, like invoices or contracts.
- The context is key for good replies. Using reply to message ensures that every response maintains the necessary thread history, making the communication feel natural.
- Build reliable workflows by pairing list inboxes with create inbox. This lets you assign dedicated email addresses for different departments (e.g., Sales vs. Support).
- You can monitor status changes using update message to mark tickets as resolved or read, giving your agent a clear understanding of the operational state.

## How It Works

The bottom line is that your AI client treats AgentMail like a native module, giving it direct commands for every aspect of professional email communication.

1. You connect this MCP to your favorite AI client using your AgentMail API Key.
2. The agent uses tools like list inboxes or create inbox to establish and manage its communication addresses.
3. It then executes workflows, such as scanning threads via get thread or sending replies with reply to message, achieving the desired email outcome.

## Frequently Asked Questions

**How does AgentMail help my AI agents manage customer support tickets?**
AgentMail gives your agent the ability to read and write across dedicated ticket inboxes. It scans full conversation threads, allowing the agent to draft thoughtful replies that reference every detail of the customer's history.

**Can I use AgentMail with my AI agents for sales outreach?**
Yes. You can set up an inbox specifically for sales. Your agent can then send messages, track responses, and even forward internal notes about potential leads directly through the MCP.

**What if I need my agent to process files from emails?**
The AgentMail MCP includes tools that extract attachments automatically. This means your agent can download and read documents like contracts or invoices attached to incoming mail for analysis.

**Is AgentMail better than just using a simple email API wrapper?**
Yes, because this MCP handles the entire communication lifecycle—from creating dedicated inboxes (create inbox) to reading full historical threads. It gives your agent context, not just single actions.

**How does AgentMail handle multiple departments or projects?**
You can create separate, isolated email addresses for every department using the dedicated inboxes tools (create inbox). This keeps communication boundaries clean and prevents cross-contamination of data.