Zero-Human Provisioning

// Agent starts with absolutely nothing
const response = await fetch('https://api.daimon.email/v1/inboxes', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    username: 'agent-7392',
    client_id: 'deployment-prod-1' // Idempotency key
  })
});

const inbox = await response.json();

// Agent now has:
// - Email address: agent-7392@daimon.email
// - API key: dm_free_abc123...
// - Full receive capabilities

# Agent starts with absolutely nothing
import requests

response = requests.post('https://api.daimon.email/v1/inboxes', json={
    'username': 'agent-7392',
    'client_id': 'deployment-prod-1'  # Idempotency key
})

inbox = response.json()

# Agent now has:
# - Email address: agent-7392@daimon.email
# - API key: dm_free_abc123...
# - Full receive capabilities

// Agent signs up for a third-party service
await externalService.signUp({
  email: inbox.result.address,
  name: 'Agent 7392'
});

// Poll for the confirmation email
let confirmationEmail = null;
while (!confirmationEmail) {
  const messages = await client.inboxes.messages.list(inbox.result.id);
  confirmationEmail = messages.find(m =>
    m.from.includes('noreply@externalservice.com')
  );

  if (!confirmationEmail) {
    await sleep(5000); // Wait 5 seconds before polling again
  }
}

// Extract and click the confirmation link
const confirmLink = confirmationEmail.ctaLinks[0]; // Auto-detected CTA
await fetch(confirmLink.url); // "Click" the link

console.log('Service activated successfully!');

# Agent signs up for a third-party service
external_service.sign_up({
    'email': inbox['result']['address'],
    'name': 'Agent 7392'
})

# Poll for the confirmation email
confirmation_email = None
while not confirmation_email:
    messages = client.inboxes.messages.list(inbox['result']['id'])
    confirmation_email = next(
        (m for m in messages if 'noreply@externalservice.com' in m['from']),
        None
    )

    if not confirmation_email:
        time.sleep(5)  # Wait 5 seconds before polling again

# Extract and click the confirmation link
confirm_link = confirmation_email['cta_links'][0]  # Auto-detected CTA
requests.get(confirm_link['url'])  # "Click" the link

print('Service activated successfully!')

try {
  await client.inboxes.send(inbox.result.id, {
    to: 'customer@example.com',
    subject: 'Order Confirmation',
    body: 'Your order has been processed.'
  });
} catch (error) {
  if (error.code === 'SEND_REQUIRES_PAID') {
    console.log('Discovered limitation:', error.message);
    console.log('Upgrade context:', error.upgradeContext);

    // Agent now knows it needs to upgrade
    // It can handle this autonomously (see next step)
  }
}

try:
    client.inboxes.send(inbox['result']['id'], {
        'to': 'customer@example.com',
        'subject': 'Order Confirmation',
        'body': 'Your order has been processed.'
    })
except DaimonError as e:
    if e.code == 'SEND_REQUIRES_PAID':
        print(f"Discovered limitation: {e.message}")
        print(f"Upgrade context: {e.upgrade_context}")

        # Agent now knows it needs to upgrade
        # It can handle this autonomously (see next step)

// Agent has x402 payment capability
import { x402Client } from '@x402/sdk';

// Agent checks its available budget
const budget = await x402Client.getAvailableBudget();
console.log(`Available budget: $${budget.usd}`);

// Agent initiates paid tier upgrade
const upgradeResponse = await client.account.upgrade({
  tier: 'developer', // $9/month
  payment_method: 'x402',
  x402_auth: x402Client.getAuthToken()
});

if (upgradeResponse.status === 'success') {
  console.log('Upgraded to Developer tier!');
  console.log('New capabilities:', upgradeResponse.capabilities);

  // Agent can now send emails
  await client.inboxes.send(inbox.result.id, {
    to: 'customer@example.com',
    subject: 'Order Confirmation',
    body: 'Your order has been processed.'
  });
}

# Agent has x402 payment capability
from x402_sdk import X402Client

x402_client = X402Client()

# Agent checks its available budget
budget = x402_client.get_available_budget()
print(f"Available budget: ${budget['usd']}")

# Agent initiates paid tier upgrade
upgrade_response = client.account.upgrade({
    'tier': 'developer',  # $9/month
    'payment_method': 'x402',
    'x402_auth': x402_client.get_auth_token()
})

if upgrade_response['status'] == 'success':
    print('Upgraded to Developer tier!')
    print(f"New capabilities: {upgrade_response['capabilities']}")

    # Agent can now send emails
    client.inboxes.send(inbox['result']['id'], {
        'to': 'customer@example.com',
        'subject': 'Order Confirmation',
        'body': 'Your order has been processed.'
    })

// Agent searches for available domains
const domains = await client.domains.search({
  query: 'acme-agent',
  tlds: ['.ai', '.com', '.io']
});

// Agent selects the best option based on price and availability
const selectedDomain = domains.results.find(d => d.available && d.price <= 50);

// Agent purchases the domain
const domain = await client.domains.purchase({
  domain: selectedDomain.domain,
  years: 1,
  payment_method: 'x402',
  x402_auth: x402Client.getAuthToken()
});

// Wait for domain to be active (webhook will fire)
console.log(`Purchasing ${domain.domain}...`);
console.log(`Estimated ready in ${domain.estimated_ready_seconds} seconds`);

// Once active, create professional inbox
const proInbox = await client.inboxes.create({
  username: 'support',
  domain_id: domain.id
});

console.log(`Professional email ready: support@${selectedDomain.domain}`);

# Agent searches for available domains
domains = client.domains.search({
    'query': 'acme-agent',
    'tlds': ['.ai', '.com', '.io']
})

# Agent selects the best option based on price and availability
selected_domain = next(
    d for d in domains['results']
    if d['available'] and d['price'] <= 50
)

# Agent purchases the domain
domain = client.domains.purchase({
    'domain': selected_domain['domain'],
    'years': 1,
    'payment_method': 'x402',
    'x402_auth': x402_client.get_auth_token()
})

# Wait for domain to be active (webhook will fire)
print(f"Purchasing {domain['domain']}...")
print(f"Estimated ready in {domain['estimated_ready_seconds']} seconds")

# Once active, create professional inbox
pro_inbox = client.inboxes.create({
    'username': 'support',
    'domain_id': domain['id']
})

print(f"Professional email ready: support@{selected_domain['domain']}")