---
title: "Planner-Executor: A Two-Agent Pattern for Reliable Email-Driven Automation"
emoji: 🤖
colorFrom: purple
colorTo: blue
sdk: static
pinned: true
tags:
  - agents
  - architecture
  - multi-agent
  - planner-executor
  - email-automation
  - claude
  - agentic-ai
---

# Planner-Executor: A Two-Agent Pattern for Reliable Email-Driven Automation

> This pattern is implemented in **ClonAgent** ([clonagent.utopiaia.com](https://clonagent.utopiaia.com)) and has been running in production since July 2025.  
> Source: [github.com/KikoCisBot/clonagent](https://github.com/KikoCisBot/clonagent)

---

## The Problem with Single-Agent Email Loops

The naive approach to email-driven AI automation looks like this:

```
email arrives → launch agent → agent reads, thinks, acts, replies → done
```

This breaks down quickly in production:

- **Long tasks block the inbox**: while Claude is deploying code (which can take minutes), new emails pile up unread
- **Context collapse**: a single agent session mixes "what should I do?" with "how do I do it?" — two very different cognitive modes
- **No retry logic**: if the action fails mid-way, the whole session is lost
- **No priority**: email #3 might be urgent but gets queued behind email #1

The Planner-Executor pattern solves all of this.

---

## The Pattern

```
┌─────────────────────────────────────────────────────────────┐
│                        Email Arrives                        │
└──────────────────────────┬──────────────────────────────────┘
                           │  (poller tick, every 60s)
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                    SCHEDULER (Planner)                      │
│                                                             │
│  Role: understand + plan                                    │
│  Input: email thread                                        │
│  Output: agent-tasks.json (list of structured tasks)       │
│  Duration: seconds                                          │
│  Blocks: nothing                                            │
└──────────────────────────┬──────────────────────────────────┘
                           │  writes agent-tasks.json
                           │  (async — Scheduler exits)
                           ▼
                   [2 min executor tick]
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                    EXECUTOR                                  │
│                                                             │
│  Role: execute pending tasks, one by one                    │
│  Input: agent-tasks.json                                    │
│  Output: task results + email replies                       │
│  Duration: seconds to minutes                               │
│  Blocks: only itself (never the Scheduler)                  │
└─────────────────────────────────────────────────────────────┘
```

Two separate Claude CLI sessions. Two separate prompts. One shared state file.

---

## Implementation

### The State File: `agent-tasks.json`

The only communication channel between Planner and Executor is a JSON file that lives in the agent's workspace:

```json
{
  "agentId": "btc-signals",
  "plan": "User requested BTC price analysis for the week. One task: generate report and reply.",
  "tasks": [
    {
      "id": "a1b2c3d4-...",
      "title": "Generate weekly BTC analysis",
      "description": "Fetch price data, compute indicators, write summary, reply to thread",
      "priority": 1,
      "status": "pending",
      "threadId": "18f3a2b...",
      "from": "kikocisneros@gmail.com",
      "createdAt": "2026-05-31T09:12:00.000Z",
      "retries": 0,
      "log": [],
      "dependsOn": []
    }
  ],
  "updatedAt": "2026-05-31T09:12:05.123Z"
}
```

**Task statuses**: `pending` → `in-progress` → `done` | `failed` | `skipped`  
**Priority**: `1` = urgent, `2` = normal, `3` = low  
**`retries`**: auto-incremented on failure and recovery  
**`log[]`**: timestamped progress entries written by the Executor during execution  
**`dependsOn[]`**: IDs of tasks that must be `done` before this one is eligible

This file is readable by humans, inspectable at any time, and survives process crashes.

---

### The Planner Prompt

The Scheduler receives a tightly scoped prompt that constrains it to planning only:

```
ROL: PLANIFICADOR

Nueva comunicación recibida:
  De: kikocisneros@gmail.com
  Asunto: Weekly BTC report please
  ThreadId: 18f3a2b...

Tu tarea (sé rápido y concreto):
1. Lee el email: python3 mail_client.py get-thread "18f3a2b..."
2. Lee el fichero de tareas actual: cat agent-tasks.json
3. Decide qué tareas hay que hacer. Por cada tarea, añádela con esta forma:
   {
     "id": "<uuid4>", "title": "...", "description": "...",
     "priority": 1, "status": "pending",
     "threadId": "...", "from": "...", "createdAt": "<iso>",
     "retries": 0, "log": [],
     "dependsOn": []   ← IDs of other tasks that must be done first
   }
   - priority: 1=urgent, 2=normal, 3=low
   - dependsOn: list task IDs in this file that must be "done" before this one runs
   - Do NOT add tasks if threadId already exists with any status other than "failed"
   - If threadId exists with status "failed", add nothing — the Executor will retry automatically
4. Actualiza el campo "plan" con tu análisis breve
5. Escribe el fichero actualizado
6. Sal cuando hayas terminado de planificar.
```

Key constraints on the Planner:
- **It never executes**. It only reads and writes `agent-tasks.json`
- **It deduplicates**: checks existing tasks by `threadId` before adding new ones
- **It models dependencies**: can express "deploy after tests pass" with `dependsOn`
- **It exits immediately** after writing the plan

---

### The Executor Prompt

The Executor picks up `agent-tasks.json` and works through it, respecting dependencies and logging progress:

```
ROL: EJECUTOR

Ejecuta las tareas pendientes de agent-tasks.json.

Proceso (repite hasta que no haya más tareas ejecutables):
1. Lee agent-tasks.json
2. Toma la tarea con status="pending" de mayor prioridad (1=urgente)
   cuyo dependsOn[] esté vacío o todas sus deps estén "done".
   Si ninguna cumple esto, sal.
3. Actualiza status a "in-progress"; añade al log[]: { "ts": "<iso>", "msg": "Iniciando: <título>" }
4. Ejecuta la tarea; añade entradas al log[] con progreso real durante la ejecución
5. Al terminar:
   - status: "done" o "failed"
   - result: descripción breve del resultado
   - updatedAt: <iso>
   - Si retries >= 3: status="failed", result="Max retries reached: <reason>"
6. Si quedan tareas pending ejecutables, vuelve al paso 1
7. Cuando no haya ninguna tarea pending ejecutable, sal

Reglas:
- Marca "failed" (no crashees) si algo falla, continúa con la siguiente
- El campo log[] es visible al usuario — úsalo para reflejar progreso real
- Usa mail_client.py para enviar respuestas de email
```

---

## Task Dependencies: Basic DAG

The `dependsOn` field turns `agent-tasks.json` into a minimal DAG (directed acyclic graph) without any external scheduler:

```json
[
  { "id": "task-run-tests",  "title": "Run test suite",    "status": "pending", "dependsOn": [] },
  { "id": "task-deploy-prod","title": "Deploy to prod",    "status": "pending", "dependsOn": ["task-run-tests"] },
  { "id": "task-notify",     "title": "Reply with result", "status": "pending", "dependsOn": ["task-deploy-prod"] }
]
```

The Executor resolves this automatically:

```javascript
function getNextTask(agentId) {
  const queue = read(agentId);
  const { tasks } = queue;
  let dirty = false;

  const pending = tasks
    .filter(t => t.status === 'pending')
    .sort((a, b) => (a.priority || 2) - (b.priority || 2));

  let result = null;
  for (const task of pending) {
    if (!task.dependsOn?.length) { result = task; break; }

    const deps = task.dependsOn.map(id => tasks.find(t => t.id === id));
    const failedDep = deps.find(d => d?.status === 'failed');

    if (failedDep) {
      // Auto-skip tasks whose dependency failed — no manual intervention needed
      task.status = 'skipped';
      task.result = `Skipped: dependency "${failedDep.title}" failed`;
      task.log.push({ ts: new Date().toISOString(), msg: task.result });
      dirty = true;
      continue;
    }

    if (deps.every(d => d?.status === 'done')) { result = task; break; }
  }

  if (dirty) write(agentId, queue);
  return result;
}
```

If `task-run-tests` fails, `task-deploy-prod` and `task-notify` are automatically skipped. No cascade failure, no stuck queue.

---

## Idempotency: Handling Re-delivered Emails

Email systems re-deliver. Networks retry. The Planner must be idempotent:

```javascript
function addTask(agentId, newTask) {
  const queue = read(agentId);
  const existing = queue.tasks.find(t => t.threadId === newTask.threadId);

  if (existing) {
    if (existing.status === 'failed') {
      // Explicit retry: reset to pending, increment retries counter
      existing.status = 'pending';
      existing.retries = (existing.retries || 0) + 1;
      existing.log.push({ ts: new Date().toISOString(), msg: `Retry #${existing.retries}` });
      write(agentId, queue);
    }
    // For any other status: silent no-op (dedup)
    return queue;
  }

  queue.tasks.push({ retries: 0, log: [], dependsOn: [], ...newTask });
  write(agentId, queue);
  return queue;
}
```

The same `threadId` arriving twice results in one task. A `failed` task arriving again resets to `pending` with `retries++`. The `retries` field lets the Executor apply exponential backoff or hard-stop after N attempts.

---

## Per-Task Progress Logging

The `log[]` array makes task execution fully observable without any external logging infrastructure:

```json
{
  "id": "task-deploy-prod",
  "status": "done",
  "log": [
    { "ts": "2026-05-31T10:00:01Z", "msg": "Iniciando: Deploy to prod" },
    { "ts": "2026-05-31T10:00:08Z", "msg": "SSH connected to 145.239.65.26" },
    { "ts": "2026-05-31T10:00:31Z", "msg": "docker pull done (847MB)" },
    { "ts": "2026-05-31T10:00:38Z", "msg": "Containers restarted, health check passed" }
  ],
  "result": "Deployed v2.1.4 successfully"
}
```

Live monitoring: `watch -n1 'cat agent-tasks.json | jq ".tasks[0].log[-3:]"'`

No Grafana. No Datadog. The file is the dashboard.

---

## Crash Recovery

When the server restarts, tasks that were `in-progress` (mid-execution) need to be reset. A one-time recovery pass runs at startup:

```javascript
function recoverStaleTasks(agentId) {
  const queue = read(agentId);
  let recovered = 0;
  for (const task of queue.tasks) {
    if (task.status !== 'in-progress') continue;
    task.status = 'pending';
    task.retries = (task.retries || 0) + 1;
    task.log.push({ ts: new Date().toISOString(), msg: 'Recovered from stale in-progress (server restart)' });
    recovered++;
  }
  if (recovered > 0) write(agentId, queue);
  return recovered;
}

// In startPoller():
function startPoller() {
  const agents = listAgents().filter(a => a.enabled && a.ready);
  for (const a of agents) taskQueue.recoverStaleTasks(a.id);
  // ... start cron jobs
}
```

A crash mid-deploy becomes a retried deploy, not a lost task.

---

## Atomic Writes

The JSON file is the single source of truth. Corruption on a mid-write crash would break everything. The fix: write to a `.tmp` file, then `rename`:

```javascript
function write(agentId, data) {
  const f = filePath(agentId);
  const tmp = f + '.tmp';
  fs.mkdirSync(path.dirname(f), { recursive: true });
  fs.writeFileSync(tmp, JSON.stringify({ ...data, updatedAt: new Date().toISOString() }, null, 2));
  fs.renameSync(tmp, f); // atomic on POSIX
}
```

`fs.renameSync` is atomic on POSIX filesystems: readers either see the old file or the new one, never a partial write.

---

## Timing and Concurrency

```
T+0s    Email arrives
T+60s   Poller tick detects new email → launches Scheduler
T+75s   Scheduler reads email, writes tasks → exits
T+120s  Executor tick fires → sees pending tasks → launches Executor  
T+180s  Executor completes tasks, replies to email → exits
T+240s  Executor tick fires → no pending tasks → skips (noop)
```

Concurrency is controlled by in-memory flags that survive the process lifetime:

```javascript
// Only one Scheduler active per agent at a time
if (agentSessions.isActive(skillId, 'scheduler')) return null;

// Only one Executor active per agent at a time  
if (agentSessions.isActive(skillId, 'executor')) return null;
```

Crucially: **the Scheduler and Executor can run simultaneously**. While the Executor is working on task #1, the Scheduler can plan tasks #2 and #3.

---

## Session Resumption

Both agents support `--resume`, which continues the same Claude conversation across invocations:

```javascript
const resumeClaudeId = sess.schedulerClaudeId || null;

const args = [
  '--output-format', 'stream-json',
  '--dangerously-skip-permissions',
  '--model', resolvedModel,
];
if (resumeClaudeId) args.push('--resume', resumeClaudeId);
```

The Executor doesn't start cold. It already knows the project structure, conventions, and recent decisions. The more emails processed, the more efficient it becomes — without a database.

---

## Why Two Agents Instead of One?

| Concern | Single Agent | Planner-Executor |
|---------|-------------|-----------------|
| New email while executing | Missed until session ends | Scheduler handles it immediately |
| Task priority | FIFO only | Explicit priority 1-2-3 |
| Task dependencies | None | `dependsOn[]` with auto-skip on failure |
| Partial failure | Whole session fails | Task marked `failed`, next task continues |
| Crash mid-task | Task lost silently | Reset to `pending` on restart, `retries++` |
| Long-running tasks | Blocks everything | Executor runs async, Scheduler stays free |
| Debugging | One long session, hard to inspect | `agent-tasks.json` + `log[]` per task |
| Cost control | Hard to limit mid-session | Monthly spend limit checked before each launch |
| Re-delivered emails | May process twice | Dedup by `threadId`, idempotent |

---

## Spending Limits

Before launching either agent, the system checks monthly spend:

```javascript
if (agent.spendingLimitMonthly != null) {
  const spent = await getMonthlySpend(skillId);  // async — must be awaited
  if (spent >= agent.spendingLimitMonthly) {
    console.warn(`monthly limit $${agent.spendingLimitMonthly} reached — launch blocked`);
    return null;
  }
}
```

The Planner is cheap (reads email, writes JSON — a few cents). The Executor is where real work — and cost — happens. Checking before each launch gives per-session cost granularity.

---

## Complete Flow Diagram

```
Inbox (IMAP/Gmail)
     │
     │  (polled every 60s)
     ▼
gmail-poller.js
     │
     ├─ Is it a !command? → handle locally, reply, mark read
     │
     └─ Is sender authorized? → yes
          │
          ▼
     launchScheduler(agent, { from, subject, threadId })
          │
          │  (Claude CLI, ROL: PLANIFICADOR)
          │  reads email thread via mail_client.py
          │  reads agent-tasks.json
          │  deduplicates by threadId
          │  appends tasks with priority + dependsOn
          │  writes agent-tasks.json (atomic)
          └─ exits
          
     (2 min later...)
     
tickExecutor()
     │
     ├─ hasPendingReady(agentId)? → no → skip
     │
     └─ yes
          │
          ▼
     launchExecutor(agent)
          │
          │  (Claude CLI, ROL: EJECUTOR)
          │  reads agent-tasks.json
          │  picks highest-priority pending task with deps satisfied
          │  marks in-progress, appends to log[]
          │  executes (code, email reply, API call, deploy...)
          │  marks done/failed with result + final log entry
          │  loops until queue empty or no more executable tasks
          └─ exits
```

---

## Implementation in ClonAgent

The full implementation is open source:

| File | Role |
|------|------|
| [`server/lib/gmail-poller.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/gmail-poller.js) | Orchestrator: poller ticks, triggers Scheduler and Executor, crash recovery on startup |
| [`server/lib/relay-client.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/relay-client.js) | Launches Scheduler and Executor via Claude CLI with role-specific prompts |
| [`server/lib/task-queue.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/task-queue.js) | Atomic reads/writes of `agent-tasks.json`, idempotent `addTask`, dependency-aware `getNextTask`, crash recovery |
| [`server/lib/agent-sessions.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/agent-sessions.js) | Tracks active Scheduler/Executor sessions, prevents overlaps |

---

## Conclusion

The Planner-Executor pattern is a practical approach to building reliable AI agents that operate on asynchronous, real-world inputs like email.

The key insight is that **planning and execution are different cognitive tasks** that benefit from separation — not just conceptually, but as separate model invocations with different prompts, different time horizons, and different failure modes.

Production use has taught us additional lessons:

- **Atomic writes** (temp + rename) prevent file corruption that would break the whole agent
- **Idempotency by `threadId`** is mandatory — email systems re-deliver, networks retry
- **`log[]` per task** makes debugging possible without any external infrastructure
- **`dependsOn[]`** enables multi-step workflows without Airflow or Temporal
- **Crash recovery** at startup means a server restart doesn't lose work in progress
- **`await` the spend check** — async bugs here mean spending limits silently don't apply

A shared JSON file replaces complex message queue infrastructure. Claude CLI's `--resume` flag provides session continuity without a database. Explicit priority and dependency fields give the agent the ability to triage and sequence, just like a human would.

The result is an agent that feels less like a script and more like a colleague: it reads your email, decides what matters, plans the work, and executes — without blocking, without crashing, and without forgetting what it learned yesterday.

---

*Implementation: [ClonAgent](https://clonagent.utopiaia.com) — open source at [github.com/KikoCisBot/clonagent](https://github.com/KikoCisBot/clonagent)*