Publish Planner-Executor pattern article

README.md

@@ -0,0 +1,356 @@
+---
+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"
+    }
+  ],
+  "updatedAt": "2026-05-31T09:12:05.123Z"
+}
+```
+
+**Task statuses**: `pending` → `in-progress` → `done` | `failed`  
+**Priority**: `1` = urgent, `2` = normal, `3` = low
+
+This file is readable by humans, inspectable at any time, and survives process crashes.
+
+---
+
+### The Planner Prompt
+
+The Scheduler (Planner) receives a tightly scoped prompt:
+
+```
+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. Añade las tareas necesarias en formato JSON:
+   { "id": "<uuid4>", "title": "...", "description": "...",
+     "priority": 1, "status": "pending", "threadId": "...",
+     "from": "...", "createdAt": "<iso>" }
+   - priority 1=urgente, 2=normal, 3=baja
+   - No dupliques tareas ya existentes para el mismo threadId
+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 exits immediately** after writing the plan
+
+---
+
+### The Executor Prompt
+
+The Executor picks up `agent-tasks.json` and works through it:
+
+```
+ROL: EJECUTOR
+
+Ejecuta las tareas pendientes de agent-tasks.json.
+
+Proceso (repite hasta que no haya más tareas pendientes):
+1. Lee agent-tasks.json
+2. Toma la tarea con status="pending" de mayor prioridad (1=urgente)
+3. Actualiza su status a "in-progress" en el fichero
+4. Ejecuta la tarea
+5. Actualiza: status="done" o "failed", result="descripción", updatedAt=<iso>
+6. Si quedan más tareas pending, vuelve al paso 1
+7. Cuando no haya ninguna tarea pending, sal
+
+Reglas:
+- Marca "failed" (no crashees) si algo falla, continúa con la siguiente
+- Usa mail_client.py para enviar respuestas de email
+```
+
+The Executor's loop is explicit in the prompt: it keeps going until the queue is empty. This means one Executor session can drain multiple tasks that accumulated while it was sleeping.
+
+---
+
+## 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 boolean flags:
+
+```javascript
+let schedulerRunning = false;
+let executorRunning  = false;
+
+// Only one Scheduler active per agent at a time
+if (agentSessions.isActive(skillId, 'scheduler')) {
+  console.log(`scheduler already active, skipping`);
+  return null;
+}
+
+// Only one Executor active per agent at a time  
+if (agentSessions.isActive(skillId, 'executor')) {
+  console.log(`executor already active, skipping`);
+  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. They only share the file — they never block each other.
+
+---
+
+## 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);
+args.push('-p', `/${skillId}\n\n${prompt}`);
+```
+
+This means the Executor doesn't start cold each time. It already knows the agent's project structure, coding conventions, and recent context from the previous session. The more emails processed, the more efficient it becomes.
+
+---
+
+## 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 |
+| Partial failure | Whole session fails | Task marked "failed", next task continues |
+| Long-running tasks | Blocks everything | Executor runs async, Scheduler stays free |
+| Debugging | One long session, hard to inspect | `agent-tasks.json` is human-readable at all times |
+| Cost control | Hard to limit mid-session | Per-task granularity, monthly spend limit enforced before each launch |
+
+---
+
+## Spending Limits
+
+Before launching either agent, the system checks monthly spend:
+
+```javascript
+if (agent.spendingLimitMonthly != null) {
+  const spent = await getMonthlySpend(skillId);
+  if (spent >= agent.spendingLimitMonthly) {
+    console.warn(`monthly limit $${agent.spendingLimitMonthly} reached — launch blocked`);
+    return null;
+  }
+}
+```
+
+This means you can run agents with hard cost caps. The Planner is cheap (reads email, writes JSON). The Executor is where the real work — and cost — happens.
+
+---
+
+## The `agent-tasks.json` as a Coordination Protocol
+
+The file acts as a simple, durable message queue. It is:
+
+- **Persistent**: survives process restarts
+- **Inspectable**: `cat agent-tasks.json` shows exactly what the agent is doing
+- **Editable by hand**: add a task manually and the Executor will pick it up
+- **Self-documenting**: the `plan` field explains the agent's current understanding
+
+This replaces Redis, RabbitMQ, or any external queue system with a 30-line module.
+
+---
+
+## Complete Flow Diagram
+
+```
+Inbox (IMAP)
+     │
+     │  (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
+          │  appends new tasks with priority
+          │  writes agent-tasks.json
+          └─ exits
+          
+     (2 min later...)
+     
+tickExecutor()
+     │
+     ├─ hasPending(agentId)? → no → skip
+     │
+     └─ yes
+          │
+          ▼
+     launchExecutor(agent)
+          │
+          │  (Claude CLI, ROL: EJECUTOR)
+          │  reads agent-tasks.json
+          │  picks highest-priority pending task
+          │  marks in-progress
+          │  executes (code, email reply, API call, deploy...)
+          │  marks done/failed with result
+          │  loops until queue empty
+          └─ exits
+```
+
+---
+
+## What This Enables in Practice
+
+An agent built on this pattern can:
+
+1. **Handle multiple simultaneous email threads** — each gets planned independently, executed in priority order
+2. **Survive long-running tasks** — a deploy that takes 3 minutes doesn't block other planning
+3. **Recover from failures gracefully** — failed tasks are logged, not lost
+4. **Learn across sessions** — `--resume` means the Executor accumulates context over time
+5. **Be audited** — `agent-tasks.json` is the full audit log of what was planned and what happened
+
+---
+
+## 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 |
+| [`server/lib/relay-client.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/relay-client.js) | Launches Scheduler and Executor via Claude CLI |
+| [`server/lib/task-queue.js`](https://github.com/KikoCisBot/clonagent/blob/main/server/lib/task-queue.js) | Reads/writes `agent-tasks.json` |
+| [`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.
+
+A shared JSON file replaces complex message queue infrastructure. Claude CLI's `--resume` flag provides session continuity without a database. And explicit priority fields give the agent the ability to triage, 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, and gets to work — 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)*