Case study

ARCHON

A self-aware personal agent.

A control plane that plans, routes, executes, and recovers across models, tools, and other coding agents, with memory and human approval built in.

This is the systems craft underneath the voice work, applied to agents. It documents how the orchestration layer is built, and where it is still rough.

Agent Orchestration · Multi-model Routing · Worker Delegation · MCP Tools · Persistent Memory

View the source →

plan

break the task into sessions, jobs, and turns

route

choose a model or a worker per step

execute

run tools and delegate real work

recover

validate results, re-enter on failure

A real multi-step task becomes a planned, routed, and recoverable run.

The problem

Most AI products fail not on the model, but on orchestration.

A single prompt in a loop demos well and breaks the moment the task has more than two steps.

Complexity leaks into application code.

Every app re-implements retries, memory, tool selection, and whether a step is safe to run.

Reliability does not come from a bigger model.

It comes from orchestration, memory, and the ability to inspect and approve what the agent actually did.

What it is

Archon is a control plane, not a chat wrapper. It plans, routes, executes, and recovers across providers and tools, with persistent memory, context compression, usage accounting, and human approval built in. A task flows through sessions and jobs, broken into turns, each with a reasoning trace, so the work stays legible while it runs.

Plans and routesWork is broken into sessions, jobs, and turns, and routed across Claude, GPT, and Gemini per task rather than hardwired to one.

Executes and recoversReal work is delegated to coding agents through a worker router and validated, not trusted blindly.

RemembersPersistent memory with context compression and distillation, plus usage and token accounting on every run.

Asks before it actsAnything consequential passes a human approval gate over Telegram before it runs. Autonomy that stays inspectable.

Architecture

Seven layers absorb the complexity that would otherwise leak into every task, from the model up to the safety gates.

01Model layer

routeAnthropic Claude, OpenAI, and Google Gemini behind one agent, chosen per task instead of hardwiring a single provider.

02Control plane

orchestrateAn orchestrator, policy, sessions, and jobs sit over execution turns, so a task is a defined flow with reasoning traces, not a black box.

03Worker delegation

delegateHeavy work is handed to real coding agents, Claude Code, Codex, and OpenCode, through a worker router that supervises them and validates the result.

04Tools and MCP

actA deep tool layer over the filesystem, web read and search, and content, plus a Model Context Protocol client so external tools plug in cleanly.

05Memory and context

rememberPersistent memory with context compression, distillation, and usage accounting, so long-running work does not drown in its own history.

06Channels

reachTerminal REPL, Telegram with human approvals, voice through STT and TTS, and live phone calls over Twilio.

07Safety

gateRedaction, policy guardrails, and human approval gates are first-class, not patched on after the fact.

What is still rough

This is active research, not a finished product. What works today is the spine: routing, tools, memory, delegation, and approvals, driven from a CLI. What still needs work is honest to name.

Worker-router recoveryRecovery on failed delegations is not yet where I want it.

Memory-compression heuristicsDeciding what to keep, distill, or drop is still being tuned.

Multi-session schedulingCoordinating concurrent long-running sessions is unfinished.

Measured results

Awaiting measured results

Reliability, recovery rate, and cost per task will be published here from verified runs. Until that data is instrumented and confirmed, this slot stays empty. No estimates.