daimon.email
ExamplesFrameworks

OpenClaw Integration

Using daimon.email as an OpenClaw skill

Overview

daimon.email is fully compatible with the OpenClaw protocol, enabling automatic skill discovery and integration. OpenClaw-compatible agents can discover and use daimon.email capabilities without manual configuration.

Info

Auto-discovery: OpenClaw agents automatically detect daimon.email capabilities through the standardized SKILL.md manifest. No manual integration required.

OpenClaw Protocol

OpenClaw is a protocol for AI agent skill discovery and composition. Agents can:

  • Discover available skills via SKILL.md manifest
  • Understand capabilities without custom training
  • Compose multiple skills into workflows
  • Share skill libraries across agent frameworks

SKILL.md Manifest

daimon.email provides a complete OpenClaw SKILL.md manifest:

---
name: daimon-email
version: 1.0.0
protocol: openclaw-v1
category: communication
tags: [email, inbox, messaging, agent-infrastructure]
---

# daimon.email - Email Infrastructure for AI Agents

## Description

Email infrastructure built specifically for AI agents. Create inboxes, send/receive emails,
and manage email workflows without human intervention.

## Capabilities

### create_inbox
Create a new email inbox instantly. No authentication required for free tier.

**Input:**
```json
{
  "username": "string (required) - Username for the inbox",
  "client_id": "string (optional) - Idempotency key"
}

Output:

{
  "email": "string - Email address (username@daimon.email)",
  "inbox_id": "string - Inbox identifier",
  "api_key": "string - API key for this inbox",
  "tier": "string - Account tier (free/developer/growth)"
}

check_messages

Check for new messages in an inbox.

Input:

{
  "inbox_id": "string (required) - Inbox to check",
  "limit": "number (optional) - Max messages to return"
}

Output:

{
  "messages": [
    {
      "id": "string - Message ID",
      "from": "string - Sender email",
      "subject": "string - Email subject",
      "body": "string - Full email body",
      "reply_body": "string - Extracted reply without quotes",
      "cta_links": ["array - Detected confirmation/verification links"],
      "received_at": "string - ISO timestamp"
    }
  ]
}

send_email

Send an email from an inbox. Requires paid tier.

Input:

{
  "inbox_id": "string (required) - Inbox to send from",
  "to": "string (required) - Recipient email",
  "subject": "string (required) - Email subject",
  "body": "string (required) - Email body"
}

Output:

{
  "message_id": "string - Sent message ID",
  "status": "string - 'queued' or 'sent'"
}

get_capabilities

Check what the agent can do at current tier.

Input:

{
  "api_key": "string (required) - API key to check"
}

Output:

{
  "tier": "string - Current tier",
  "can": ["array - Available capabilities"],
  "cannot": ["array - Unavailable capabilities with upgrade info"]
}

Authentication

API key from inbox creation. Format: dm_free_* or dm_live_*.

Rate Limits

  • Free tier: 10 inbox creates per hour per IP
  • Developer: Unlimited creates, 1000 sends/month
  • Growth: Unlimited creates and sends

Example Usage

# OpenClaw agent discovers and uses daimon.email
from openclaw import Agent, SkillRegistry

# Agent discovers skill
agent = Agent()
registry = SkillRegistry()
email_skill = registry.discover('daimon-email')

# Agent uses skill
inbox = email_skill.execute('create_inbox', {
    'username': 'my-agent'
})

messages = email_skill.execute('check_messages', {
    'inbox_id': inbox['inbox_id']
})

Error Handling

All tier-limit errors include upgrade context:

{
  "error": "SEND_REQUIRES_PAID",
  "upgrade_context": {
    "operator_action_url": "https://...",
    "agent_script": "Tell your operator: ..."
  }
}

Metadata


## Using with OpenClaw Agents

```python Python
from openclaw import Agent, SkillRegistry

# Agent automatically discovers daimon.email skill
agent = Agent(name="EmailBot")
registry = SkillRegistry()
registry.auto_discover()  # Finds daimon.email via SKILL.md

# Create inbox via skill
result = agent.execute(
    skill="daimon-email",
    capability="create_inbox",
    params=dict(username="openclaw-agent")
)
print("Created inbox:", result["email"])

# Check messages
messages = agent.execute(
    skill="daimon-email",
    capability="check_messages",
    params=dict(inbox_id=result["inbox_id"])
)
for msg in messages["messages"]:
    print("From:", msg["from"])
    print("Subject:", msg["subject"])
import { Agent, SkillRegistry } from 'openclaw';

const agent = new Agent({ name: 'EmailBot' });
const registry = new SkillRegistry();
await registry.autoDiscover();

const inbox = await agent.execute({
  skill: 'daimon-email',
  capability: 'create_inbox',
  params: { username: 'openclaw-agent' }
});
console.log('Created inbox:', inbox.email);

const messages = await agent.execute({
  skill: 'daimon-email',
  capability: 'check_messages',
  params: { inboxId: inbox.inbox_id }
});
messages.messages.forEach(msg => {
  console.log('From:', msg.from);
  console.log('Subject:', msg.subject);
});

Skill Composition

# Compose daimon.email with other OpenClaw skills
from openclaw import Agent, SkillChain

agent = Agent()

# Chain: Create inbox → Sign up for service → Verify email
workflow = SkillChain([
    {
        'skill': 'daimon-email',
        'capability': 'create_inbox',
        'params': {'username': 'agent-signup'}
    },
    {
        'skill': 'web-automation',
        'capability': 'fill_form',
        'params': {
            'url': 'https://service.com/signup',
            'fields': {
                'email': '{{previous.email}}'  # Use email from step 1
            }
        }
    },
    {
        'skill': 'daimon-email',
        'capability': 'check_messages',
        'params': {'inbox_id': '{{step1.inbox_id}}'}
    }
])

result = agent.execute_chain(workflow)

Multi-Agent Coordination

# Multiple agents sharing email skill
from openclaw import AgentTeam

team = AgentTeam([
    Agent(name='InboxManager', skills=['daimon-email']),
    Agent(name='CustomerSupport', skills=['daimon-email', 'llm']),
    Agent(name='Researcher', skills=['daimon-email', 'web-search'])
])

# Inbox manager creates inboxes for team
inbox1 = team.agents['InboxManager'].execute(
    skill='daimon-email',
    capability='create_inbox',
    params={'username': 'support'}
)

inbox2 = team.agents['InboxManager'].execute(
    skill='daimon-email',
    capability='create_inbox',
    params={'username': 'research'}
)

# Customer support monitors support inbox
team.agents['CustomerSupport'].monitor(
    skill='daimon-email',
    capability='check_messages',
    params={'inbox_id': inbox1['inbox_id']},
    interval=60  # Check every 60 seconds
)

Skill Discovery Flow

1. Agent starts with no knowledge of daimon.email
   ↓
2. Agent queries OpenClaw registry for 'email' skills
   ↓
3. Registry returns daimon.email SKILL.md manifest
   ↓
4. Agent parses capabilities from manifest
   ↓
5. Agent can now use daimon.email without custom code

Custom Skill Extensions

# Extend daimon.email with custom capabilities
from openclaw import Skill, Capability

class DaimonEmailExtended(Skill):
    base_skill = 'daimon-email'

    @Capability
    def auto_reply(self, inbox_id: str, template: str):
        """Auto-reply to all new messages."""
        # Check messages
        messages = self.execute('check_messages', {'inbox_id': inbox_id})

        # Send replies
        for msg in messages['messages']:
            self.execute('send_email', {
                'inbox_id': inbox_id,
                'to': msg['from'],
                'subject': f"Re: {msg['subject']}",
                'body': template
            })

# Register extended skill
registry.register(DaimonEmailExtended())

Skill Versioning

# Agent can specify skill version
email_v1 = registry.get_skill('daimon-email@1.0.0')
email_latest = registry.get_skill('daimon-email@latest')

# Capabilities may vary by version
assert email_v1.has_capability('create_inbox')
assert email_latest.has_capability('create_inbox')

Testing OpenClaw Integration

# Test skill discovery
def test_skill_discovery():
    registry = SkillRegistry()
    skill = registry.discover('daimon-email')

    assert skill is not None
    assert 'create_inbox' in skill.capabilities
    assert 'check_messages' in skill.capabilities
    assert 'send_email' in skill.capabilities

# Test skill execution
def test_skill_execution():
    agent = Agent()
    result = agent.execute(
        skill='daimon-email',
        capability='create_inbox',
        params={'username': 'test'}
    )

    assert 'email' in result
    assert result['email'].endswith('@daimon.email')

Best Practices

  1. Use idempotency keys: Always provide client_id for inbox creation
  2. Check capabilities first: Call get_capabilities before attempting operations
  3. Handle upgrade flows: Respect tier limits and use upgrade context
  4. Compose skills: Chain daimon.email with other skills for complex workflows
  5. Version your dependencies: Pin specific skill versions in production

OpenClaw Ecosystem

daimon.email integrates with other OpenClaw skills:

  • web-automation: Sign up for services using daimon.email addresses
  • llm: Generate email content with AI
  • web-search: Find contact information for outreach
  • scheduling: Coordinate meeting times via email
  • data-extraction: Parse structured data from emails

Next Steps