How to Give Your Hermes Agent an Email Address

The one skill the messenger is missing

Hermes is built to grow. It picks up new skills as it works, runs on hardware you control, and keeps going where a one-shot assistant would stop. But the moment a task touches email (confirming a signup, reading a one-time code, replying to a vendor), it stalls. There's no inbox it owns and no clean way to read what arrives. Fitting the messenger with a real, authenticated mailbox closes that gap, and it takes about two minutes.

Step 1: Create your Robotomail account

Head to robotomail.com and create an account. The signup form is short, four fields, but one of them is doing more work than it looks, so it's worth a walk-through.

• Name
  A human-readable label for the account, your team or project name is fine. It doesn't affect the agent's address.
• Human email
  Your own inbox, used for the verification link, billing receipts, and account notices. This is never the agent's address, keep the two separate.
• Mailbox name
  The important one. Whatever you type here becomes the agent's live address on the shared platform domain, type hermes-agent and the agent owns hermes-agent@robotomail.co. The field checks availability as you type and turns green when the name is free.
• Password
  Protects the dashboard you'll use to manage keys, domains, and billing. Your agent never needs it, agents authenticate with an API key, not your password.

Submit the form and Robotomail sends a verification link to your human email. Click it to confirm the account, then finish signup by starting your free trial. A fresh account must verify before it can send, which keeps the platform's sender reputation clean for everyone.

Step 2: Verify, then copy your API key

After you verify your email and start your free trial, you land on the dashboard. The mailbox itself is created at signup; starting the trial is what activates your API key, so the agent can actually send and receive. This is account management only, there's no inbox UI to click through here, because Hermes does the reading and writing over the API. The dashboard is where you watch activity, manage mailboxes and domains, and create the API keys your agent authenticates with.

Now grab your API key. Go to Settings → API keys, click Create key, give it a name your future self will recognize (for example hermes-agent), and Robotomail shows the full key exactly once. It starts with rm_.

Copy that key directly into a secret manager like 1Password, don't leave it in a scratch file, don't hard-code it into the skill, and don't paste it into a chat window. If you lose it, you can't recover it; you just create a new one and delete the old. The key is the agent's entire credential, so treat it like a password.

Step 3: Drop the skill into Hermes

Hermes has no skill store for this, and it doesn't need one. A Robotomail skill is just a markdown file. Tell Hermes to add it from robotomail.com/skill and it drops the file straight into its skills folder, no install step, no client library, no build. Then point it at your API key in 1Password rather than pasting the secret into the chat.

Add the robotomail skill from https://robotomail.com/skill
into your skills folder.

My Robotomail API key is in 1Password under "Robotomail".
Pull it from there when you need it. Don't ask me to paste it
into the chat.

Because the skill lives as plain markdown in the agent's own folder, everything stays on the server you control, and a vault reference keeps the secret out of the transcript and logs. The skill describes a small set of tools (send, list, read, and reply) so the agent has everything it needs and nothing it doesn't. See the full agent skill.

Live demo: watch the messenger work

The agent now owns a mailbox, hermes-agent@robotomail.co. From Gmail, send it a verification email, exactly like any signup would. Within seconds Hermes receives a clean JSON event: sender, subject, the parsed body, the code, and the thread. No IMAP, no raw MIME.

{
  "event": "message.received",
  "timestamp": "2026-06-06T10:00:00.000Z",
  "data": {
    "message_id": "b2c3d4e5-6789-4abc-def0-222222222222",
    "mailbox_id": "a1b2c3d4-5678-4def-abcd-111111111111",
    "mailbox_address": "hermes-agent@robotomail.co",
    "from": "no-reply@acme.com",
    "to": ["hermes-agent@robotomail.co"],
    "subject": "Confirm your email",
    "body_text": "Your verification code is 481920. It expires in 10 minutes.",
    "thread_id": "c3d4e5f6-789a-4bcd-ef01-333333333333",
    "received_at": "2026-06-06T10:00:00.000Z"
  }
}

The agent grabs the code straight out of the body, finishes the signup, then forwards the confirmation to you, one POST to the messages endpoint. Robotomail returns the message ID. Inbound to outbound, fully autonomous.

curl -X POST https://api.robotomail.com/v1/mailboxes/mbx_hermes/messages \
  -H "Authorization: Bearer rm_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "to": ["you@company.com"],
    "subject": "Signup confirmed ✓",
    "bodyText": "Done. I read the code, finished the signup, and the account is active."
  }'

{
  "message": {
    "id": "b2c3d4e5-6789-4abc-def0-222222222222",
    "direction": "OUTBOUND",
    "toAddresses": ["you@company.com"],
    "status": "SENT",
    "threadId": "c3d4e5f6-789a-4bcd-ef01-333333333333"
  }
}

Going further

Need more? It's all there. Three of the most common next steps:

• Bring your own custom domain
  The platform domain (@robotomail.co) is great for getting started. When you want the agent to send as hermes@yourcompany.com, add a custom domain, Robotomail generates the DNS records you need (MX, a send MX, SPF, DMARC, and one or more DKIM records) and verifies them as soon as propagation completes.
• Fire a webhook on every inbound message
  Register a webhook URL and Robotomail POSTs every inbound message to it within seconds of receipt, signed with HMAC-SHA256 so you can verify it before trusting the payload.
• Subscribe to a live event stream
  No public URL to expose on your server? Open a server-sent event (SSE) connection to GET /v1/events and the agent streams inbound events over a single long-lived request, no webhook endpoint required.

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

$ npx @robotomail/cli domain verify acme.com
⏳ checking DNS...
✓ MX       propagated
✓ SPF      valid
✓ DKIM     aligned
✓ DMARC    policy ok
✓ acme.com is fully verified.

GET /v1/events?events=message.received
Authorization: Bearer rm_your_api_key
Accept: text/event-stream

# Each inbound message arrives as a standard SSE frame:
id: 1717668000000-0000-a3f1
event: message.received
data: {"event":"message.received","timestamp":"2026-06-06T10:00:00.000Z","data":{"message_id":"b2c3d4e5-...","mailbox_address":"hermes-agent@robotomail.co","from":"no-reply@acme.com","subject":"Confirm your email","body_text":"Your verification code is 481920.","received_at":"2026-06-06T10:00:00.000Z"}}

The stream replays missed events on reconnect via Last-Event-ID, see the Events (SSE) API docs for the full frame format and reconnect semantics.

For the full picture (the four agent tools, error handling, and a copy-paste signup-to-send walkthrough) see the longer guide for any AI agent and the companion OpenClaw walkthrough.

Frequently asked questions