Hermes Agent Integration

Two Integrations, One Agent

Hermes Agent is Nous Research's open-source agent runtime (github.com/NousResearch/hermes-agent, MIT license) — launched February 2026 and sitting at roughly 229k GitHub stars with v0.20.0 “Herald” shipped August 3, 2026, as of this writing. One disambiguation up front: Hermes Agent the runtime is not the Nous Hermes model family it often runs on, and neither is Meta's Hermes JavaScript engine — this page is about the agent runtime documented at hermes-agent.nousresearch.com.

Dead Simple plugs into Hermes in two distinct ways:

• Option A — email tools via MCP. Point Hermes's MCP client at Dead Simple's remote server and the agent can create inboxes, send, read, reply, and wait for verification codes on demand.
• Option B — a Dead Simple inbox as Hermes's email channel. Hermes ships a built-in email gateway (IMAP polling for inbound, SMTP for replies). A Dead Simple inbox is a real mailbox with IMAP/SMTP credentials, so it slots straight in as the dedicated account the Hermes docs recommend.

They compose: Option B gives humans an address to email your agent; Option A gives the agent programmatic control over as many inboxes as it needs.

Option A: Email Tools via Remote MCP

Hermes Agent has first-class MCP support, including remote servers with custom headers (and OAuth 2.1 with PKCE, though Dead Simple just uses a bearer key). Add a deadsimple entry to the mcp_servers block in ~/.hermes/config.yaml:

mcp_servers:
  deadsimple:
    url: https://api.deadsimple.email/mcp
    headers:
      Authorization: "Bearer ${DSE_API_KEY}"

Put the key itself in ~/.hermes/.env so it never lands in the config file:

DSE_API_KEY=dse_your_api_key

Verify the connection, then reload MCP servers in your running session. You can also register the server interactively with hermes mcp add instead of editing YAML:

# Test the server connection and list its tools
hermes mcp test deadsimple

# In the running Hermes session
/reload-mcp

# Then prompt naturally:
"Create an inbox called 'Hermes Support', then send a welcome
email to user@example.com and tell me when a reply arrives."

The tools appear namespaced as mcp_deadsimple_* — e.g. mcp_deadsimple_send_email, mcp_deadsimple_wait_for_email — alongside Hermes's built-ins (terminal, read_file, web_search, etc.). Hermes remembers inbox IDs in its persistent memory across restarts.

Prefer to run the server locally over stdio? Install pip install "deadsimple-email[mcp]" and use the command form instead:

mcp_servers:
  deadsimple:
    command: python
    args: ["-m", "deadsimple.mcp"]
    env:
      DSE_API_KEY: "dse_your_api_key"

Available MCP Tools

Once connected, Hermes Agent has access to all fourteen Dead Simple tools:

Want a guardrail so Hermes can never delete inboxes or forward mail out of the account? Exclude those tools in the config:

mcp_servers:
  deadsimple:
    url: https://api.deadsimple.email/mcp
    headers:
      Authorization: "Bearer ${DSE_API_KEY}"
    tools:
      exclude: [delete_inbox, forward_message]

Option B: A Dead Simple Inbox as Hermes's Email Channel

Hermes has a built-in email gateway: it polls an IMAP mailbox for new mail and replies over SMTP, so anyone (on your allow-list) can talk to the agent just by emailing it. The Hermes docs recommend a dedicated account for this rather than a personal one — and that is exactly what a Dead Simple inbox is. Every inbox exposes raw IMAP/SMTP credentials via GET /v1/inboxes/{inbox_id}/credentials.

# 1. Create a dedicated inbox for the gateway
curl -s https://api.deadsimple.email/v1/inboxes \
  -H "Authorization: Bearer dse_your_api_key" \
  -d '{"display_name": "Hermes Gateway"}'
# → {"inbox_id": "inb_a1b2c3", "email": "hermes-gateway@yourco.deadsimple.email", ...}

# 2. Fetch its IMAP/SMTP credentials
curl -s https://api.deadsimple.email/v1/inboxes/inb_a1b2c3/credentials \
  -H "Authorization: Bearer dse_your_api_key"
# → imap: mail.deadsimple.email:993, smtp: mail.deadsimple.email:587, username + password

Drop the credentials into Hermes's email channel config in ~/.hermes/.env:

EMAIL_ADDRESS=hermes-gateway@yourco.deadsimple.email
EMAIL_PASSWORD=password-from-credentials-endpoint
EMAIL_IMAP_HOST=mail.deadsimple.email
EMAIL_IMAP_PORT=993
EMAIL_SMTP_HOST=mail.deadsimple.email
EMAIL_SMTP_PORT=587
EMAIL_ALLOWED_USERS=you@yourco.com,teammate@yourco.com

Restart Hermes and the agent now has a public address. EMAIL_ALLOWED_USERS is the important line: only senders on that list can issue instructions by email, so the inbox can be public without the agent taking orders from strangers. Because it is a Dead Simple inbox, you also get the dashboard view, message history, and API access to everything flowing through the gateway.

Custom Skill (Alternative)

If you prefer a tighter, code-first integration than MCP, register a custom Hermes skill that uses the Python SDK (pip install deadsimple-email) directly:

import os
from deadsimple import DeadSimple

client = DeadSimple(os.environ["DSE_API_KEY"])

def send_email(to: str, subject: str, body: str, inbox_id: str = None):
    """Send an email. Creates a Hermes inbox if none is provided."""
    if not inbox_id:
        inbox = client.inboxes.create(display_name="Hermes Agent")
        inbox_id = inbox.inbox_id

    result = client.messages.send(
        inbox_id=inbox_id,
        to=[to],
        subject=subject,
        text_body=body,
    )
    return f"Sent {result.message_id} from {inbox_id}"

def check_inbox(inbox_id: str):
    """Summarize recent messages in an inbox."""
    result = client.messages.list(inbox_id, limit=5)
    return [
        {"from": m.from_email, "subject": m.subject, "snippet": m.snippet}
        for m in result.messages
    ]

Drop the file into Hermes's skills/ directory and Hermes's skill-learner will register the functions automatically. From that point forward, send_email and check_inbox show up in the tools list alongside everything else.

Example Prompts

Once connected, try these with your Hermes Agent:

• "Create an inbox called 'Hermes Support' and email hello@example.com a welcome message." — Hermes calls create_inbox, then send_email, and stores the inbox ID in its memory.
• "Sign up for that SaaS trial with a fresh inbox and enter the verification code." — create_inbox, then get_verification_code does the OTP extraction in one call.
• "Every 10 minutes, check the Hermes Support inbox and reply to any new customer message asking for their account ID." — Hermes writes this as a recurring skill and runs it without further prompting.
• "Summarize unread messages across all my inboxes and email the summary to me at me@example.com." — Hermes uses list_inboxes, read_messages across each, then send_email.
• "Forward the most recent billing inquiry to finance@company.com and reply to the sender acknowledging the handoff." — list_threads + forward_message + reply_to_message.
• "How close am I to my plan's email limit this month?" — Hermes calls get_usage and reports back.

Why Dead Simple Is a Good Fit for Hermes

• First-class MCP, not a wrapper. Hermes's mcp_servers block and Dead Simple's remote MCP server speak the same protocol natively — no shim, no REST-to-MCP bridge, no local process to babysit.
• Real mailboxes, both directions. The same inbox that serves MCP tools also exposes IMAP/SMTP credentials, so it doubles as Hermes's email channel — no shared Gmail account that Google can suspend.
• Webhooks that feed Hermes's memory. Inbound messages trigger webhooks in real time, so Hermes's persistent memory is fresh without polling.
• Deliverability is handled. SPF, DKIM, DMARC, and bounce monitoring run on the Dead Simple side. Hermes never learns what a DKIM selector is — and shouldn't.
• Free plan is enough to build. Five inboxes and 5,000 emails/month on the free tier, no card required — enough to run the MCP tools and the email channel in production on low-volume workloads.

Full Walkthrough

For a step-by-step guide — including a production-shaped support-triage skill and troubleshooting tips — read the full blog post:

How to Give Hermes Agent Email Using Dead Simple

FAQ

Related Integrations

• MCP Server — the underlying MCP server used by this integration
• Claude Agent SDK — same remote MCP server from Anthropic's agent SDK
• OpenClaw — same MCP server, different AI agent host
• Browser Use — verification-code flows for browser agents
• Python SDK — for building custom Hermes skills programmatically
• CLI — manage inboxes and email from the terminal