Introducing Robotomail: Email for AI Agents

Editorial update, 18 September 2026: This is the original founding story. The publication date and launch context are preserved. Setup and product details below have been corrected where they could mislead a builder today. See email for AI agents, current pricing and the quickstart for the current product.

The missing primitive

I've been thinking a lot about what AI agents are still missing. Not intelligence. Not model quality. Not frameworks. Those are moving fast. What's still missing is infrastructure that makes agents feel like real participants in software systems. Email is one of those missing primitives. (I wrote more about this on my personal blog.)

If you want an agent to actually do useful work in the real world, eventually it needs an inbox. It needs to send reminders, receive replies, react to incoming messages, and operate with a real identity instead of faking everything through a human's Gmail account. I hit this while building OpenClaw agents: OAuth setup, JSON credentials files, creating separate Google accounts to avoid suspicion. It was more account and credential management than I wanted for a dedicated agent workflow.

I wanted the mailbox and the conversation to be the starting point. Sending notifications is useful, but my agents also needed somewhere for replies to arrive and a way to recover the context. That was the product I wanted to build.

The last option is running your own mail server. Postfix, Dovecot, DNS records, TLS certs, IP reputation, spam filtering, deliverability monitoring. If you've done it, you know: it's a full-time job. If you haven't, trust the people who have, don't. You're building an AI product, not becoming a mail server admin.

What Robotomail is

Robotomail is email infrastructure purpose-built for AI agents. One API call to sign up. One API call to send an email. Every agent gets a real mailbox with a real email address, not a forwarding alias, not a shared inbox, not a webhook-only endpoint. A proper agent@yourdomain.com address that can send and receive like any other mailbox on the internet.

Robotomail connects inbound mail to messages and threads your application can retrieve, and sends outbound mail through its API. For a custom domain, the service returns DNS records for you to publish and verify. Webhooks, SSE and polling give your application different ways to discover incoming messages. The current docs describe the supported setup and payloads.

I built Robotomail because I needed it. While building OpenClaw agents that had to communicate with people over email, the options I tried did not give me the workflow I wanted without extra setup or mail-server operations. The moment I watched Hal receive an email via SSE, process it, and fire back a reply, all without a human in the loop, and I knew this needed to be its own product.

How it works

Robotomail is a REST API. Four steps to go from nothing to a working email agent.

Step 1: Sign up. The API supports account creation and mailbox provisioning. Follow the current onboarding guide and complete account verification before sending.

curl -X POST https://api.robotomail.com/v1/signup \
  -H "Content-Type: application/json" \
  -d '{
    "email": "you@example.com",
    "password": "a-strong-password",
    "slug": "myagent"
  }'

You get back your API key, a mailbox at myagent@robotomail.co, and your send limits. The slug becomes both your account identifier and your default email address prefix. Sending requires account verification and remains subject to the account’s controls.

Step 2: Send an email. Use the mailbox ID from your signup response to send a message. Include bodyText; add bodyHtml for an HTML alternative.

For a Free-plan test, replace the recipient below with your verified signup email address. Free allows 10 sends and 10 receives per calendar month with that address only; upgrade for other correspondents or a custom domain.

curl -X POST https://api.robotomail.com/v1/mailboxes/{mailbox_id}/messages \
  -H "Authorization: Bearer rm_..." \
  -H "Content-Type: application/json" \
  -d '{
    "to": ["recipient@example.com"],
    "subject": "Hello from my AI agent",
    "bodyText": "This email was sent by an autonomous agent via Robotomail."
  }'

That's it. The email goes out with proper DKIM signatures. Threading is handled automatically: use the original RFC email Message-ID in inReplyTo to identify the message you are answering. Keep that value separate from the database ID used for retrieval; subject matching alone is not a reliable application boundary.

Step 3: Register a webhook. Tell Robotomail where to send inbound messages. You can scope webhooks to a specific mailbox or receive events for all of them.

curl -X POST https://api.robotomail.com/v1/webhooks \
  -H "Authorization: Bearer rm_..." \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-app.com/webhooks/email",
    "events": ["message.received"],
    "mailboxId": "{mailbox_id}"
  }'

Every webhook delivery is signed with HMAC-SHA256 via the X-Robotomail-Signature header. Verify the raw request bytes before parsing; the signature does not make the email content trustworthy. The webhook secret is returned when you create the webhook, store it securely.

Step 4: Receive and respond. Incoming messages within your plan's allowance trigger a webhook with message content, sender and recipient fields, a thread ID and attachment metadata. Your agent fetches the message to obtain the RFC Message-ID, decides what to do, and sends its reply with that value in inReplyTo. See the webhook schema for the exact fields.

If you prefer server-sent events over webhooks, Robotomail also supports SSE streaming at the /v1/events endpoint. Same data, different delivery mechanism. Use whichever fits your architecture.

What makes it different

• Agent self-onboarding. The API supports account and mailbox setup. Account verification and sending controls still apply. Follow the quickstart docs.
• Automatic threading. Replies are threaded by In-Reply-To and References headers first, then by normalized subject matching. Your application should keep its own task-to-thread mapping and check the relevant context.
• Per-mailbox rate limits. Mailbox sending controls and account-level quotas both matter. See current limits and add application limits appropriate to the task.
• Custom domains. Bring your own domain for branded email. Robotomail returns the required DNS records. Publish them at your DNS provider and complete verification. DMARC policy is an additional domain-authentication consideration; use the custom-domain guide.
• No OAuth dance. Authentication is a single API key in the Authorization header. Keep the key secure, scope it to the workflow and rotate or revoke it when needed.
• CLI tool. The @robotomail/cli npm package gives you a command-line interface that wraps the full API. Useful for debugging, scripting, and giving agents a tool-use interface.
• Scoped API keys. Create API keys that are restricted to specific mailboxes. Give each agent only the access it needs, least privilege out of the box.

Who it's for

The number one use case right now is OpenClaw agents, autonomous agents that need to reach out to people, respond to inquiries, and manage ongoing email conversations. But Robotomail works with any agent framework: LangChain, CrewAI, AutoGen, Claude, Codex. If your agent needs to communicate over email, this is the infrastructure layer you've been missing.

It's also for teams that need to give multiple agents their own email identities without managing mail server infrastructure. Spin up a mailbox per agent, per workflow, or per customer. Tear them down when you're done. It's infrastructure, not a commitment.

What's next

We're just getting started. Custom domains, attachments, automatic threading, and webhook event filtering (so you only receive the events you care about) are already live. The roadmap is driven by what builders actually need, if you have a use case that isn't covered, I want to hear about it.

Get started

Start with email for AI agents for the current product, or follow the quickstart guide to connect a mailbox. Check current plans and limits when sizing a workflow.

Create a mailbox