Why daimon.email?

The Problem: Email APIs Are Built for Humans

Every major email provider was designed for human developers, not autonomous AI agents. This creates fundamental friction when agents try to use email infrastructure:

OAuth Barriers

• SendGrid requires OAuth flows that need browser-based authentication
• Gmail API forces users through Google's consent screen
• Microsoft Graph requires Azure AD setup and admin approval
• Mailgun needs account verification via email (chicken-and-egg problem)

AI agents can't click "Allow" buttons or solve CAPTCHAs. They're stuck.

Manual Provisioning

Even after authentication, traditional providers require human involvement:

• Domain verification: SSH into your DNS provider, add TXT records manually
• Payment setup: Enter credit card details through a web form
• Account verification: Phone numbers, email confirmations, identity checks
• API key generation: Navigate dashboards, copy-paste credentials

None of this is automatable. Your agent must stop and ask for help.

Human-Centric Responses

Traditional email APIs return machine-readable JSON, but they don't guide agents on what to do next:

// Typical error response from other providers
{
  "error": "insufficient_permissions",
  "status": 403
}

An AI agent gets this error and has no idea how to resolve it. Should it retry? Upgrade? Contact a human? The API doesn't say.

The daimon.email Solution

daimon.email is the first email infrastructure designed for complete agent autonomy. Zero human touchpoints, from inbox creation to domain provisioning.

1. Instant Inbox Creation

Create an inbox in one API call. No authentication required for free tier.

curl -X POST https://api.daimon.email/v1/inboxes \
  -H "Content-Type: application/json" \
  -d '{"username": "my-agent", "client_id": "unique-123"}'

Response in <200ms. Your agent immediately has:

• Email address: my-agent@daimon.email
• API key: dm_free_abc123...
• Full receive capabilities

No OAuth. No verification. No waiting.

2. Agent-Aware Responses

Every response includes next_steps[] to guide agent behavior:

{
  "result": {
    "id": "inb_abc123",
    "address": "my-agent@daimon.email",
    "api_key": "dm_free_7d8a9b0c..."
  },
  "next_steps": [
    "Use the api_key to authenticate future requests",
    "Check /v1/inboxes/inb_abc123/messages to poll for incoming mail",
    "Register a webhook at /v1/webhooks to receive real-time events"
  ]
}

Errors are equally helpful:

{
  "error": "SEND_REQUIRES_PAID",
  "next_steps": [
    "Call POST /v1/upgrade-link to generate an upgrade URL",
    "Present the URL to your operator with context: 'I need sending access to complete this task'"
  ],
  "upgrade_context": {
    "operator_action_url": "https://daimon.email/upgrade?token=...",
    "operator_action_label": "Add a payment method to enable sending",
    "agent_script": "Tell your operator: I need sending access. Here's a direct upgrade link: {url}"
  }
}

The agent knows exactly what to do: generate a magic link and present it to its operator.

3. Self-Awareness Built In

The /v1/capabilities endpoint tells agents exactly what they can and cannot do at their current tier:

{
  "result": {
    "tier": "free",
    "can": [
      {
        "action": "receive_messages",
        "description": "Receive unlimited inbound emails"
      }
    ],
    "cannot": [
      {
        "action": "send_messages",
        "reason": "SEND_REQUIRES_PAID",
        "unlock": "https://daimon.email/upgrade?token=...",
        "api_call": "POST /v1/upgrade-link"
      }
    ]
  }
}

No more guessing. The agent knows its limitations and how to overcome them.

4. Magic Upgrade Flows

When an agent hits a tier limit, it can autonomously request an upgrade:

try {
  await client.inboxes.send('inb_abc123', {
    to: 'user@example.com',
    subject: 'Hello'
  });
} catch (error) {
  if (error.code === 'SEND_REQUIRES_PAID') {
    // Generate magic upgrade link
    const link = await client.account.createUpgradeLink();

    // Agent presents to operator
    console.log(error.upgradeContext.agentScript);
    // "Tell your operator: I need sending access. Here's a direct upgrade link: https://..."
  }
}

The operator clicks one link, adds payment, and the agent immediately gains new capabilities. No dashboard navigation, no config files, no restarts.

5. Agent-Optimized Features

Features designed specifically for autonomous agents:

• Reply extraction: Automatic removal of quoted text using TalonJS
• CTA detection: Auto-detection of confirmation/verification links in emails
• Threading: Automatic message grouping via In-Reply-To headers
• Allowlists/Blocklists: Per-inbox email filtering
• Scheduled sending: send_at parameter for future delivery
• Idempotency: client_id on all creation operations

6. Free Tier That Actually Works

Unlike other providers, the free tier is fully functional for receive-only use cases:

• Unlimited inbound emails
• Webhook notifications
• Reply extraction
• CTA detection
• Threading
• Allowlist/blocklist

Most email APIs have "free tiers" that are really just trials. daimon.email's free tier is permanent and production-ready.

Who Is This For?

AI Agent Developers

Building autonomous agents that need email capabilities:

• Customer support agents
• Sales development agents
• Integration testing agents
• Account verification agents
• Monitoring/alerting agents

No-Code Agent Platforms

Platforms that let users build agents without code:

• Zapier AI Actions
• Make.com scenarios
• n8n workflows
• Bubble.io plugins

daimon.email provides the missing email primitive these platforms need.

AI Researcher/Hobbyists

Experimenting with agent autonomy:

• Testing multi-agent systems
• Building personal AI assistants
• Prototyping agent communication protocols
• Researching agent-to-agent email

Comparison with Other Providers

Real-World Use Case: Account Verification Agent

Here's how an agent uses daimon.email to sign up for a service autonomously:

1. Create inbox (1 API call, <200ms)

   POST /v1/inboxes {"username": "agent-7392"}
   # Returns: agent-7392@daimon.email

2. Sign up for external service

   POST https://external-service.com/signup
   {"email": "agent-7392@daimon.email"}

3. Receive confirmation email (via webhook or polling)

   GET /v1/inboxes/inb_abc123/messages
   # Returns: message with cta_links: [{ url: "https://...", text: "Confirm Account" }]

4. Extract and visit confirmation link

   GET https://external-service.com/confirm?token=xyz
   # Account verified!

Total human involvement: zero.

With SendGrid, Resend, or Gmail API, the agent would be blocked at step 1 (OAuth) and never complete the flow.

What About Security?

Rate Limiting

• Free tier: 10 inbox creates per hour per IP
• Prevents abuse while allowing legitimate agent use
• Paid tiers have higher limits

API Key Scoping

• Account API keys: Manage account-wide settings
• Inbox API keys: Scoped to single inbox
• Keys can be rotated via dashboard

HMAC-Signed Webhooks

All webhook payloads are signed with HMAC-SHA256:

import { verifyWebhookSignature } from 'daimon-email';

const signature = req.headers['x-daimon-signature'];
const isValid = verifyWebhookSignature(req.body, signature, webhook.secret);

Allowlist/Blocklist

Per-inbox sender filtering:

POST /v1/inboxes/inb_abc123/lists
{
  "type": "allowlist",
  "pattern": "*@trusted-domain.com"
}

Only emails from trusted-domain.com will be accepted.

Pricing Philosophy

daimon.email pricing is designed for agents, not humans:

• Free tier: Unlimited receiving, perfect for verification use cases
• Developer tier ($9/month): Send up to 10,000 emails/month
• Growth tier ($49/month): Send up to 100,000 emails/month
• Enterprise tier: Custom limits and SLAs

Getting Started

Ready to give your agent email superpowers?

Support

• Status: status.daimon.email
• GitHub: github.com/daimon-email
• Discord: discord.gg/daimon
• Email: support@daimon.email