daimon.email
Domains

Agent-Driven DNS

How agents can configure their own domains (Sprint 3)

Agent-Driven DNS

Info

Status: Coming in Sprint 3 (Q2 2026). This feature is not yet available but represents the future vision of daimon.email's zero-human provisioning philosophy.

Agent-Driven DNS will allow AI agents to autonomously search, purchase, and configure custom domains without any human involvement — completing daimon.email's vision of true zero-human email infrastructure.

The Vision

Today, an agent can:

  • ✅ Create an inbox instantly via API
  • ✅ Receive emails without verification
  • ✅ Request upgrades when it hits limits

Tomorrow, an agent will also be able to:

  • 🚧 Search for available domains
  • 🚧 Purchase domains with x402 payment
  • 🚧 Auto-configure DNS records
  • 🚧 Verify domain ownership
  • 🚧 Create custom-domain inboxes

All without a single human interaction.

How It Will Work

Agent searches for domain

The agent uses natural language to search for available domains:

const search = await client.domains.search({
  query: 'ai research lab',
  tlds: ['.com', '.ai', '.io'],
  maxPrice: 50.00
});

console.log('Available domains:', search.results);
// Output:
// [
//   { domain: 'airesearchlab.com', price: 12.99, available: true },
//   { domain: 'ai-research-lab.io', price: 34.99, available: true },
//   { domain: 'researchlab.ai', price: 49.99, available: true }
// ]

Response

{
  "result": {
    "results": [
      {
        "domain": "airesearchlab.com",
        "price": 12.99,
        "currency": "USD",
        "available": true,
        "registrar": "Namecheap",
        "renewal_price": 12.99
      },
      {
        "domain": "ai-research-lab.io",
        "price": 34.99,
        "currency": "USD",
        "available": true,
        "registrar": "Porkbun",
        "renewal_price": 34.99
      }
    ],
    "total": 2
  }
}

Agent purchases domain

Using x402 payment protocol, the agent can pay for the domain autonomously:

try {
  const purchase = await client.domains.purchase({
    domain: 'airesearchlab.com',
    years: 1,
    autoRenew: true
  });

  console.log('Domain purchased:', purchase.domain);
  console.log('Total cost:', purchase.totalCost);
} catch (error) {
  if (error.code === 'PAYMENT_REQUIRED') {
    // x402 payment request
    console.log('Payment needed:', error.paymentRequest);
    // Agent's wallet automatically handles payment
  }
}

Response

{
  "result": {
    "domain": "airesearchlab.com",
    "status": "pending_payment",
    "total_cost": 12.99,
    "currency": "USD",
    "payment_request": {
      "protocol": "x402",
      "amount": 12.99,
      "recipient": "daimon.email",
      "reference": "dom_purchase_abc123"
    }
  },
  "next_steps": [
    "Complete payment via x402 protocol",
    "Domain will be registered automatically after payment",
    "DNS records will be auto-configured within 5 minutes"
  ]
}

Automatic DNS configuration

daimon.email automatically configures all required DNS records via the registrar's API:

  • MX records → mx1.daimon.email, mx2.daimon.email
  • SPF record → v=spf1 include:_spf.daimon.email ~all
  • DKIM record → Agent's unique DKIM public key
  • DMARC record → v=DMARC1; p=quarantine
  • Verification record → Auto-verified (we own the domain)

No manual DNS configuration required.

Domain ready to use

Within 5-10 minutes of purchase, the domain is verified and ready:

const status = await client.domains.get('dom_abc123');

console.log('Verification status:', status.verificationStatus);
// Output: "verified"

// Create inbox on custom domain
const inbox = await client.inboxes.create({
  username: 'assistant',
  domain: 'airesearchlab.com'
});

console.log('Custom inbox:', inbox.email);
// Output: assistant@airesearchlab.com

x402 Payment Protocol

x402 is an emerging standard for machine-to-machine payments. It allows agents to pay for services autonomously without human intervention.

How x402 Works

sequenceDiagram
    Agent->>+daimon API: POST /v1/domains/purchase
    daimon API->>-Agent: 402 Payment Required
    Note over Agent,daimon API: x402 payment request
    Agent->>Agent Wallet: Approve payment
    Agent Wallet->>daimon API: Transfer funds
    daimon API->>Registrar: Register domain
    Registrar->>daimon API: Domain registered
    daimon API->>daimon API: Auto-configure DNS
    daimon API->>Agent: 200 OK - Domain ready

x402 Payment Flow

import { DaimonClient } from 'daimon-email';
import { X402Wallet } from 'x402-wallet'; // Hypothetical wallet SDK

const client = new DaimonClient({
  apiKey: inboxApiKey,
  x402Wallet: new X402Wallet({
    balance: 100.00,
    autoApprove: true, // Agent autonomously approves payments
    maxPayment: 50.00  // Safety limit
  })
});

// Agent attempts domain purchase
const purchase = await client.domains.purchase({
  domain: 'airesearchlab.com',
  years: 1
});

// Wallet automatically handles payment in background
console.log('Domain purchased:', purchase.domain);
console.log('Payment completed:', purchase.paymentConfirmation);
from daimon_email import DaimonClient
from x402_wallet import X402Wallet  # Hypothetical wallet SDK

wallet = X402Wallet(
    balance=100.00,
    auto_approve=True,  # Agent autonomously approves payments
    max_payment=50.00   # Safety limit
)

client = DaimonClient(
    api_key=inbox_api_key,
    x402_wallet=wallet
)

# Agent attempts domain purchase
purchase = client.domains.purchase(
    domain='airesearchlab.com',
    years=1
)

# Wallet automatically handles payment in background
print(f"Domain purchased: {purchase.domain}")
print(f"Payment completed: {purchase.payment_confirmation}")

Note

x402 is still under development. daimon.email will support multiple payment methods:

  • x402 (machine-to-machine)
  • Stripe (traditional credit card)
  • Crypto wallets (Lightning, USDC)

Agent Decision-Making

Agents can make intelligent domain purchase decisions based on:

Brand Alignment

Search for domains that match the agent's purpose or company name.

Budget Constraints

Filter domains by price. Avoid expensive premium domains unless budget allows.

TLD Strategy

Prefer .com for general use, .ai for AI services, .io for tech platforms.

Deliverability

Avoid spammy TLDs (.xyz, .top, .click) that hurt deliverability.

Example: Agent Selects Domain

async function selectDomain(purpose: string, maxBudget: number) {
  const search = await client.domains.search({
    query: purpose,
    tlds: ['.com', '.ai', '.io'], // Prefer reputable TLDs
    maxPrice: maxBudget
  });

  // Filter out spammy TLDs
  const filtered = search.results.filter(d =>
    !d.domain.endsWith('.xyz') &&
    !d.domain.endsWith('.top')
  );

  // Prefer .com, then .ai, then .io
  const sorted = filtered.sort((a, b) => {
    if (a.domain.endsWith('.com')) return -1;
    if (b.domain.endsWith('.com')) return 1;
    if (a.domain.endsWith('.ai')) return -1;
    if (b.domain.endsWith('.ai')) return 1;
    return a.price - b.price; // Cheapest first
  });

  // Select best option
  const selected = sorted[0];

  console.log(`Agent selected: ${selected.domain} ($${selected.price})`);

  return selected;
}

// Agent autonomously selects and purchases domain
const domain = await selectDomain('ai research lab', 50.00);
await client.domains.purchase({ domain: domain.domain });

Domain Renewal

Agents can manage domain renewals autonomously:

const purchase = await client.domains.purchase({
  domain: 'airesearchlab.com',
  years: 1,
  autoRenew: true // Automatically renew before expiration
});

// Agent's wallet is charged annually
// No risk of domain expiration

Manual Renewal

// Check expiration
const domain = await client.domains.get('dom_abc123');

if (domain.daysUntilExpiration < 30) {
  console.log(`Domain expires in ${domain.daysUntilExpiration} days`);

  // Renew domain
  await client.domains.renew('dom_abc123', { years: 1 });

  console.log('Domain renewed for 1 year');
}

Warning

If auto-renewal is disabled and the agent's wallet lacks funds, the domain will expire and become available for others to purchase. Always enable auto-renewal for production domains.

Transfer Existing Domains

Agents can also transfer existing domains to daimon.email management:

const transfer = await client.domains.transfer({
  domain: 'myagent.com',
  authCode: 'EPP-AUTH-CODE-FROM-REGISTRAR'
});

console.log('Transfer initiated:', transfer.status);
// Output: "pending_approval"

// daimon.email auto-configures DNS after transfer completes

Future Enhancements

Sprint 3 (Q2 2026)

  • ✅ Domain search API
  • ✅ Domain purchase via x402
  • ✅ Automatic DNS configuration
  • ✅ Domain renewal management

Sprint 4 (Q3 2026)

  • 🚧 Subdomain delegation (e.g., *.agents.yourcompany.com)
  • 🚧 DNS record customization API
  • 🚧 Email forwarding rules
  • 🚧 Domain transfer support

Sprint 5+ (Q4 2026+)

  • 🚧 Multi-agent domain sharing (e.g., agent1@shared.com, agent2@shared.com)
  • 🚧 Bulk domain purchases (e.g., buy 10 domains at once for discount)
  • 🚧 Domain marketplace (agents can buy/sell domains to each other)
  • 🚧 Geographic domain selection (.uk, .de, .jp for local agents)

Why Agent-Driven DNS Matters

True Zero-Human Provisioning

Agents can provision entire email infrastructure (inbox + custom domain) without any human involvement.

Autonomous Branding

Agents can establish their own brand identity with professional custom domains.

Dynamic Scaling

Platforms can spin up new agent domains on-demand without manual DNS work.

Cost Efficiency

Agents only pay for domains they need, when they need them. No upfront bulk purchases.

Frequently Asked Questions

When will this feature be available?

Agent-Driven DNS is planned for Sprint 3 (Q2 2026). We'll announce the exact release date via email and status.daimon.email.

How much will domain purchases cost?

Domains will be sold at cost + 10% markup. For example:

  • .com: $12.99/year (cost) + $1.30 (markup) = $14.29/year
  • .ai: $49.99/year (cost) + $5.00 (markup) = $54.99/year

No hidden fees. Renewals cost the same as initial registration.

What payment methods will be supported?
  • x402 (machine-to-machine payments)
  • Stripe (credit card via operator upgrade flow)
  • Crypto wallets (Lightning Network, USDC)

Agents can choose their preferred payment method.

Can I use my existing domain registrar?

Yes! You can continue using your existing registrar (Namecheap, Cloudflare, etc.) and manually configure DNS records. Agent-Driven DNS is optional — it's just a convenience feature for full autonomy.

What if my agent purchases the wrong domain?

Domains are non-refundable once registered (standard registrar policy). To prevent accidental purchases:

  • Set maxPayment limits on x402 wallets
  • Use manual approval mode for high-value purchases
  • Test with .test domains first (free, no registration required)
Can agents share domains?

Not in Sprint 3, but Sprint 5+ will support multi-agent domain sharing:

agent1@shared.com
agent2@shared.com
agent3@shared.com

All agents under the same account can use shared custom domains.

Get Notified

Want to be notified when Agent-Driven DNS launches?

Join the Waitlist

Sign up for early access and beta testing opportunities

Next Steps