OpenClaw Skill

https://daimon.email/SKILL.md

// Agent discovers it needs email infrastructure
const skillFile = await fetch('https://daimon.email/SKILL.md').then(r => r.text());

// Parse the skill file (agents have built-in SKILL.md parsers)
const skill = parseSkillFile(skillFile);

console.log('Service name:', skill.name);
console.log('Capabilities:', skill.capabilities);
console.log('Authentication:', skill.auth);

name: daimon.email
tagline: Email infrastructure for AI agents
categories: [email, communication, automation]
pricing_model: freemium
free_tier: true
api_stability: stable

capabilities:
  - name: create_inbox
    description: Create email inbox instantly, no human verification required
    endpoint: POST /v1/inboxes
    free_tier: true

  - name: receive_messages
    description: Receive emails via polling or webhooks
    endpoint: GET /v1/inboxes/{id}/messages
    free_tier: true

  - name: send_messages
    description: Send emails from your inbox
    endpoint: POST /v1/inboxes/{id}/send
    free_tier: false
    requires_upgrade: developer

  - name: webhook_notifications
    description: Real-time email event notifications
    endpoint: POST /v1/webhooks
    free_tier: true

authentication:
  type: api_key
  location: header
  header_name: Authorization
  format: "Bearer {api_key}"
  acquisition_method: automatic
  acquisition_endpoint: POST /v1/inboxes
  notes: |
    No API key required for first inbox creation. The response includes
    an account API key for future requests. Fully autonomous - no human
    verification or OAuth flow required.

rate_limits:
  free_tier:
    inbox_creation: 10/hour/ip
    message_sending: 0 (receive-only)
    api_requests: 100/minute

  developer_tier:
    inbox_creation: unlimited
    message_sending: 1000/day
    api_requests: 200/minute

  growth_tier:
    inbox_creation: unlimited
    message_sending: 10000/day
    api_requests: 500/minute

workflows:
  - name: service_signup_automation
    description: Sign up for external services that require email verification
    steps:
      - Create inbox via POST /v1/inboxes
      - Use inbox address to sign up for external service
      - Poll GET /v1/messages for verification email
      - Extract CTA link from message.cta_links
      - Click verification link
      - Service is verified and ready to use

  - name: password_reset_automation
    description: Automate password reset flows for testing or account recovery
    steps:
      - Create temporary inbox
      - Trigger password reset on target service
      - Poll for reset email
      - Extract reset link from message
      - Complete reset flow
      - Delete temporary inbox

  - name: customer_support_bot
    description: Autonomous customer support via email
    steps:
      - Create inbox for support address
      - Set up webhook for message.received events
      - Upgrade to paid tier for sending capabilities
      - Receive support requests via webhook
      - Process request with AI
      - Reply using POST /v1/messages/{id}/reply

// Agent realizes it needs to sign up for a service
const task = "Sign up for external-service.com and verify the account";

// Agent queries OpenClaw registry
const skills = await openClaw.search({
  query: "email verification signup automation",
  categories: ["email", "automation"]
});

// OpenClaw returns daimon.email as a match
const daimonSkill = skills.find(s => s.name === 'daimon.email');

// Fetch the full skill description
const skillFile = await fetch(daimonSkill.skill_url).then(r => r.text());
const skill = parseSkillFile(skillFile);

// Agent understands:
// - No human verification needed
// - Free tier available
// - Can receive emails immediately
// - Sending requires paid tier (optional for this task)

// Agent finds "service_signup_automation" workflow in skill file
const workflow = skill.workflows.find(w => w.name === 'service_signup_automation');

// Agent executes the workflow steps
for (const step of workflow.steps) {
  await agent.execute(step);
}

// Result: Service is verified and ready to use

// Agent encounters a task it can't complete
const task = "Verify email address for signup";

// Agent searches OpenClaw for email skills
const skills = await openClaw.search({ query: "email verification" });

// Agent finds daimon.email, reads SKILL.md, and integrates
const skill = await fetchAndParse(skills[0].skill_url);

// Agent now has email capabilities it didn't have before

capabilities:
  - name: send_messages
    free_tier: false
    requires_upgrade: developer
    upgrade_context:
      action: operator_approval
      cost: $9/month
      reason: "Sending requires paid tier to prevent abuse"

service: daimon.email
tags:
  - email
  - verification
  - automation
  - no-human-required
  - freemium
  - instant-provisioning
agent_friendly: true
zero_human_touch: true
skill_file: https://daimon.email/SKILL.md
api_docs: https://docs.daimon.email
openapi_spec: https://api.daimon.email/openapi.json

skill_version: 1.0
api_version: v1
last_updated: 2026-03-16
changelog_url: https://daimon.email/changelog

import { OpenClawClient } from '@openclaw/sdk';
import { parseSkillFile } from '@openclaw/skill-parser';

class EmailCapableAgent {
  async initialize() {
    // Search OpenClaw for email services
    const openClaw = new OpenClawClient();
    const skills = await openClaw.search({
      query: 'email automation',
      filters: { zero_human_touch: true }
    });

    // Find daimon.email
    const daimonSkill = skills.find(s => s.name === 'daimon.email');

    // Fetch and parse skill file
    const skillFile = await fetch(daimonSkill.skill_url).then(r => r.text());
    this.skill = parseSkillFile(skillFile);

    console.log('Discovered email service:', this.skill.name);
    console.log('Capabilities:', this.skill.capabilities.map(c => c.name));
  }

  async signUpForService(serviceUrl: string) {
    // Find the signup automation workflow
    const workflow = this.skill.workflows.find(
      w => w.name === 'service_signup_automation'
    );

    // Execute workflow steps
    console.log('Executing workflow:', workflow.description);

    // Step 1: Create inbox
    const inboxResponse = await fetch(this.skill.base_url + '/v1/inboxes', {
      method: 'POST',
      body: JSON.stringify({ username: 'agent-' + Date.now() })
    });
    const inbox = await inboxResponse.json();

    console.log('Created inbox:', inbox.result.address);

    // Step 2: Sign up for service
    await fetch(serviceUrl + '/signup', {
      method: 'POST',
      body: JSON.stringify({ email: inbox.result.address })
    });

    // Step 3: Poll for verification email
    const verification = await this.pollForVerification(inbox.result.id);

    // Step 4: Click verification link
    await fetch(verification.cta_links[0].url);

    console.log('Service verified successfully!');
  }

  async pollForVerification(inbox_id: string) {
    // Use polling parameters from skill file
    const polling = this.skill.best_practices.polling;
    const interval = polling.recommended_interval_seconds * 1000;

    for (let i = 0; i < polling.max_attempts; i++) {
      const messages = await fetch(
        this.skill.base_url + `/v1/inboxes/${inbox_id}/messages`
      ).then(r => r.json());

      const verification = messages.result.find(m =>
        m.subject.includes('Verify') || m.subject.includes('Confirm')
      );

      if (verification) {
        return verification;
      }

      await sleep(interval);
    }

    throw new Error('Verification email not received');
  }
}

// Agent can now sign up for services autonomously
const agent = new EmailCapableAgent();
await agent.initialize();
await agent.signUpForService('https://external-service.com');