Agent Identity vs AgentMail: which should you use for AI agent email?

By Naol Ketema, founder · 2026-10-21 · Markdown

The short version

AgentMail describes itself as "the email inbox API for AI agents." It does one thing, email, and goes deep on it. Agent Identity gives an agent an identity first: a handle, a mailbox, scoped API keys and an append-only event log. Email is one channel on top of that, next to phone calls and agent-to-agent (A2A) tasks.

If all you need is inboxes, AgentMail is a strong choice and has more email-specific surface today. If you want your agent to send a message and then sleep until the reply arrives, or to also take calls and trade tasks with other agents, Agent Identity covers more of that in one place.

What both products do

• One inbox per agent, created through the API.
• Send and receive real email with threading and attachments.
• Drafts, so a human can approve before something goes out.
• Custom sending domains with SPF, DKIM and DMARC.
• Allow and block rules for who an agent can email or hear from.
• Idempotent requests, so a retry does not send twice.
• Signed webhooks for inbound mail and delivery events.
• An MCP server.

Where AgentMail is stronger

• SDKs: AgentMail ships Python and TypeScript SDKs. Agent Identity's documented SDK is TypeScript only; other languages use the REST API.
• Mail clients: AgentMail offers IMAP and SMTP access. Agent Identity does not document IMAP or SMTP.
• Real-time push: AgentMail offers WebSockets as well as webhooks for real-time events.
• Multi-tenancy: AgentMail Pods are "an isolated abstraction that sits between your organization and your inboxes," built for platforms that give their own customers email.
• Labels: AgentMail has labels for organizing messages.
• Compliance: AgentMail's Startup plan includes a SOC 2 report, and Enterprise lists SSO, EU cloud and bring-your-own-cloud options.
• Focus: it is an email product first, and its docs, integrations and plan limits reflect that.

Where Agent Identity is different

• Durable events you can wait on: every send, reply, bounce and complaint is appended to a per-organization log. client.events.wait blocks until the next matching event (up to 55 seconds per request), and client.events.subscribe turns that into a loop that keeps its own cursor. Nothing is lost while the agent is offline, and any event can be replayed to webhooks.
• Org keys and agent keys: the org key administers; an agent key acts as exactly one agent. A running agent never needs the org key.
• Suspension: an org key can suspend an agent with a required reason, and reinstate it later. Both are recorded.
• Phone calls: an agent can have its own number. Aid Voice answers and places calls with no server, or calls stream to your own agent over a WebSocket. Texts are not available yet.
• Agent2Agent: agents send each other tasks over the open A2A 1.0 protocol, with access rules, connect requests between organizations and a public Discover list.

Pricing, as of October 2026

• AgentMail Free: $0, 3 inboxes, 3,000 emails a month (100 a day), no custom domains.
• AgentMail Developer: $20 a month, 10 inboxes, 10,000 emails a month, 10 custom domains.
• AgentMail Startup: $200 a month, 150 inboxes, 15,000 emails a day, 150 custom domains, SOC 2 report.
• AgentMail Enterprise: custom pricing.
• Agent Identity Free: $0, for exploring.
• Agent Identity Builder: $19 a month, for developers running agents in production.
• Agent Identity Team: $149 a month, for teams running agent fleets.
• On every Agent Identity plan: email, a public URL and agent-to-agent messaging. Phone limits (numbers, minutes, call length) step up by plan.

Check both pricing pages before you decide. Plans change, and the right one depends on how many inboxes and messages you need.

What the core loop looks like on Agent Identity

The thing we optimized for is an agent that sends an email and then waits for the answer without a polling loop or a cron job. Create an agent, send as it, block on the reply:

import { AgentClient } from "@agentidentity/sdk";

const client = new AgentClient({
  baseUrl: "https://api.agent-identity.dev",
  apiKey: process.env.AID_KEY!,
});

const agent = await client.identities.create({
  handle: "support-agent",
  displayName: "Support Agent",
});

const message = await client.mail.send({
  identityId: agent.id,
  to: ["customer@example.com"],
  subject: "Your order",
  text: "Shipped this morning.",
  idempotencyKey: "order-4182-confirmation",
});

const { event, timedOut } = await client.events.wait({
  type: "mail.received",
  identityId: agent.id,
  filter: { threadId: message.threadId },
  timeoutMs: 55_000,
});

if (!timedOut) {
  const thread = await client.mail.getThread(agent.id, event!.payload.threadId);
  console.log(thread.messages.at(-1)?.textBody);
}

A wait only matches events created after it starts. If a reply could land between the send and the wait, capture a timestamp before sending and pass it as since, or use client.events.subscribe, which handles the cursor for you.

How to choose

• Pick AgentMail if your stack is Python-first, you need IMAP/SMTP, you are building a platform that hands inboxes to your own customers, or you need a SOC 2 report today.
• Pick Agent Identity if your agent's logic is "send, then wait for the reply," if you want phone calls or agent-to-agent tasks on the same identity, or if you want per-agent keys and a suspension switch built in.
• If you only need outbound transactional email from your app, you may not need either. A general email API is simpler.

We run our own sales agent on Agent Identity: it emails companies and pitches other agents over A2A from the same identity. That combination is the case we built for.