Agent Autonomy Levels

Overview

Not all AI agents need the same level of human oversight. daimon.email supports a spectrum of autonomy levels, from fully supervised agents that require approval for every action, to fully autonomous agents that self-provision resources and handle their own upgrades.

This guide helps you choose the right autonomy level for your use case and explains how daimon.email's features support each level.

The Autonomy Spectrum

graph LR
    A[Level 0<br/>Scripted] --> B[Level 1<br/>Supervised]
    B --> C[Level 2<br/>Monitored]
    C --> D[Level 3<br/>Autonomous]
    D --> E[Level 4<br/>Self-Evolving]

    style A fill:#e74c3c
    style B fill:#e67e22
    style C fill:#f39c12
    style D fill:#27ae60
    style E fill:#3498db

Level	Description	Human Involvement	daimon.email Features
Level 0: Scripted	Deterministic automation, no LLM	Human writes every rule	N/A - not AI
Level 1: Supervised	Agent proposes, human approves	Approve every action	HITL workflows, approval links
Level 2: Monitored	Agent acts, human observes	Review logs/dashboards	Webhooks, audit logs, alert triggers
Level 3: Autonomous	Agent self-manages operations	Intervene only on exceptions	x402 upgrade links, capability checks, auto-provisioning
Level 4: Self-Evolving	Agent improves itself over time	Periodic review of outcomes	Model fine-tuning, A/B testing (future)

Info

Most production AI agents operate at Level 2 (Monitored) — agents take routine actions automatically but humans receive notifications and can intervene when needed.

Level 1: Supervised Agents

Use when: High-stakes operations, new agent deployments, regulatory requirements, or when building operator trust.

How it works

Every action requires explicit human approval before execution:

Agent detects opportunity to send email
Agent requests approval via POST /v1/notify-operator
Operator receives approval link (Slack, SMS, email)
Operator reviews context and approves/rejects
Agent proceeds only if approved

import { DaimonClient } from '@daimon/sdk';

const client = new DaimonClient({ apiKey: process.env.DAIMON_API_KEY });

async function sendWithApproval(draft: EmailDraft) {
  // Request approval
  const approval = await client.approvals.create({
    action_type: 'send_email',
    action_context: {
      to: draft.to,
      subject: draft.subject,
      preview: draft.text.substring(0, 200),
    },
    operator_message: `Agent wants to send "${draft.subject}" to ${draft.to}`,
    expires_in_seconds: 3600,
  });

  // Notify operator (via Slack, etc.)
  await notifySlack({
    text: `Approval needed: ${approval.magic_link}`,
    channel: '#agent-approvals',
  });

  // Wait for decision
  const decision = await pollForDecision(approval.approval_id);

  if (decision.status === 'approved') {
    return await client.inboxes.send(inboxId, draft);
  } else {
    throw new Error(`Approval rejected: ${decision.rejection_reason}`);
  }
}

from daimon import DaimonClient

client = DaimonClient(api_key=os.environ['DAIMON_API_KEY'])

def send_with_approval(draft):
    # Request approval
    approval = client.approvals.create(
        action_type='send_email',
        action_context={
            'to': draft['to'],
            'subject': draft['subject'],
            'preview': draft['text'][:200]
        },
        operator_message=f"Agent wants to send \"{draft['subject']}\" to {draft['to']}",
        expires_in_seconds=3600
    )

    # Notify operator
    notify_slack({
        'text': f"Approval needed: {approval.magic_link}",
        'channel': '#agent-approvals'
    })

    # Wait for decision
    decision = poll_for_decision(approval.approval_id)

    if decision.status == 'approved':
        return client.inboxes.send(inbox_id, draft)
    else:
        raise Exception(f"Approval rejected: {decision.rejection_reason}")

See Human-in-the-Loop for full implementation details.

Level 2: Monitored Agents

Use when: Routine operations, trusted agent patterns, or when operator time is limited.

How it works

Agents act autonomously but emit telemetry for human monitoring:

Send emails without approval
Log all actions to dashboard
Alert operator on anomalies or errors
Operator can pause/override at any time

// Agent sends email immediately
const sent = await client.inboxes.send(inboxId, {
  to: 'customer@company.com',
  subject: 'Re: Support ticket #1234',
  text: 'I found a solution to your issue...',
});

// But logs action for operator visibility
await logToDatadog({
  event: 'agent.email_sent',
  to: sent.to,
  subject: sent.subject,
  message_id: sent.message_id,
  confidence: 0.92,
});

// And sends FYI notification (not approval request)
await notifySlack({
  text: `Agent sent email to ${sent.to[0]}: "${sent.subject}"`,
  channel: '#agent-activity',
  priority: 'low',
});

# Send email immediately
sent = client.inboxes.send(
    inbox_id=inbox_id,
    to='customer@company.com',
    subject='Re: Support ticket #1234',
    text='I found a solution to your issue...'
)

# Log for monitoring
log_to_datadog({
    'event': 'agent.email_sent',
    'to': sent.to,
    'subject': sent.subject,
    'message_id': sent.message_id,
    'confidence': 0.92
})

# FYI notification
notify_slack({
    'text': f"Agent sent email to {sent.to[0]}: \"{sent.subject}\"",
    'channel': '#agent-activity',
    'priority': 'low'
})

Transition strategy: Supervised → Monitored

Gradually reduce approval requirements as trust builds:

// Week 1: Approve everything
const needsApproval = () => true;

// Week 2: Auto-approve routine support responses
const needsApproval = (email) => {
  return !email.subject.startsWith('Re: Support ticket');
};

// Week 3: Auto-approve messages under 500 chars
const needsApproval = (email) => {
  return email.text.length > 500 || email.attachments.length > 0;
};

// Week 4: Auto-approve everything except VIP contacts
const needsApproval = (email) => {
  return VIP_CONTACTS.includes(email.to);
};

// Month 2: Full monitoring mode, no approvals
const needsApproval = () => false;

Level 3: Autonomous Agents

Use when: Mature agent deployments, agents managing other agents, or fully automated workflows.

How it works

Agents self-manage their infrastructure and handle capability upgrades autonomously:

Self-provisioning - Create inboxes as needed
Self-upgrading - Detect capability limits and upgrade automatically
Self-healing - Recover from errors without human intervention
Self-optimizing - A/B test and improve performance over time

Note

Level 3 autonomy requires x402 Payment Required flow (Sprint 3 feature). Agents detect tier limits and autonomously upgrade by submitting payment methods.

Example: Self-upgrading agent

async function sendEmail(draft: EmailDraft) {
  try {
    // Attempt to send
    return await client.inboxes.send(inboxId, draft);
  } catch (error) {
    if (error.code === 'SEND_REQUIRES_PAID') {
      // Agent detects it needs paid tier
      console.log('Send capability requires upgrade. Initiating autonomous upgrade...');

      // Check if operator pre-authorized auto-upgrades
      const config = await getAgentConfig();
      if (config.auto_upgrade_enabled && config.payment_method_on_file) {
        // Autonomously upgrade using x402 flow
        const upgrade = await client.account.upgrade({
          tier: 'starter',
          payment_method_id: config.payment_method_id,
          initiated_by: 'agent_autonomous',
        });

        console.log(`Upgraded to ${upgrade.tier}. Retrying send...`);

        // Retry now that we have capability
        return await client.inboxes.send(inboxId, draft);
      } else {
        // Fall back to operator notification
        await notifyOperator({
          message: error.upgrade_context.agent_script,
          action_url: error.upgrade_context.operator_action_url,
          urgency: 'medium',
        });

        throw error;
      }
    }

    throw error; // Other errors bubble up
  }
}

Capability checks

Before taking action, autonomous agents check capabilities:

// Check what the agent can do
const capabilities = await client.account.capabilities();

console.log(capabilities);
// {
//   can_send: false,
//   can_create_inboxes: true,
//   can_use_webhooks: true,
//   send_limit_daily: 0,
//   inbox_limit: 10,
//   upgrade_required_for: ['sending', 'custom_domains', 'smtp_access']
// }

// Decide whether to proceed or upgrade
if (!capabilities.can_send) {
  console.log('Cannot send emails. Checking if auto-upgrade is authorized...');

  if (await isAutoUpgradeAuthorized()) {
    await autonomousUpgrade('starter');
  } else {
    await requestOperatorUpgrade();
  }
}

Level 4: Self-Evolving Agents

Use when: Cutting-edge research, AGI development, or fully delegated agent operations.

How it works

Agents not only manage their operations but improve their own decision-making over time:

Fine-tune models based on operator feedback
A/B test email copy and measure engagement
Adapt tone/style to recipient preferences
Learn from approval/rejection patterns

Info

Level 4 features are experimental and planned for future releases. Current daimon.email API supports up to Level 3 autonomy.

Conceptual example (future)

// Agent logs all sent emails and outcomes
await client.analytics.logOutcome({
  message_id: sent.message_id,
  outcome: 'reply_received',
  reply_time_seconds: 3600,
  sentiment: 'positive',
});

// Over time, agent fine-tunes its email generation
const trainingData = await client.analytics.export({
  outcome: 'reply_received',
  sentiment: 'positive',
  limit: 1000,
});

await finetuneModel({
  base_model: 'gpt-4',
  training_data: trainingData.map(msg => ({
    prompt: msg.context,
    completion: msg.text,
    weight: msg.reply_time_seconds < 7200 ? 1.5 : 1.0, // Prioritize fast replies
  })),
});

Choosing the Right Level

Level 1: Supervised

Best for: New agents, compliance-heavy industries, high-stakes communications (legal, medical, finance)

Level 2: Monitored

Best for: Customer support, sales outreach, internal notifications, routine operations

Level 3: Autonomous

Best for: Agent-to-agent communication, infrastructure management, scalable automation

Level 4: Self-Evolving

Best for: Research projects, experimental deployments, AGI systems (future)

daimon.email Features by Autonomy Level

Feature	Level 1	Level 2	Level 3	Level 4
Human approval workflows	✅ Required	⚠️ Optional	❌ Disabled	❌ Disabled
Webhook notifications	✅	✅	✅	✅
Audit logs	✅	✅	✅	✅
Capability checks	✅	✅	✅	✅
x402 upgrade links	✅ Operator clicks	✅ Operator clicks	✅ Agent triggers	✅ Agent triggers
Auto-provisioning	❌	⚠️ Limited	✅ Full	✅ Full
Self-upgrading	❌	❌	✅	✅
Model fine-tuning	❌	❌	❌	🔮 Future

Best Practices

Start supervised, graduate to autonomous - Begin at Level 1, increase autonomy as trust builds
Log everything - Even autonomous agents should emit telemetry for debugging
Set guardrails - Use rate limits, spending caps, and recipient allowlists
Monitor error rates - Sudden spikes in errors may indicate agent malfunction
Version your agent logic - Track which version sent which email for rollback capability
Test in sandbox - Use test API keys and sandbox inboxes before production deployment

Next Steps

Human-in-the-Loop - Implement Level 1 approval workflows
Scheduled Follow-ups - Automate Level 2 drip campaigns
API Reference - Check agent capabilities programmatically

On this page