A platform where named agents work on my codebase and I drive them from my phone. I built it for my own work and I use it every day. This page is what is actually in it — including the part that still breaks.
Running a single coding agent needs no architecture. Running a dozen does. They overwrite each other's files, they inherit one another's context until every prompt carries everyone's history, and any one of them can do something you cannot undo.
Isolation, cost, and irreversibility. Those three are what the design is for.
agents (named roles) each with its own instruction context ├─ supervisor ────┐ ├─ planner │ message queue ├─ developer ├──▶ agents consult each other, ├─ reviewer │ asynchronously, by slug ├─ rebuild specialist ───┘ └─ … identity per-agent slug, verified server-side supervisor gate anything irreversible stops here instance A ◀── federation ──▶ instance B separate machines, separate trust boundary and key. one workstation can ask the other to deploy on its behalf.
Every agent gets its own instruction file and settings rather than one shared global prompt. This is the piece that mattered most: without it agents bleed into each other, and token cost grows with every agent you add. With it, cost stays bounded as the roster grows.
Each agent carries a slug that the server verifies against the known roster before acting on a request. An agent cannot speak as another agent.
Agents send messages to each other rather than calling each other synchronously. In practice they consult one another — a plan will cite the message id of the agent it asked.
Irreversible actions — deploys, deletions, self-modification — do not execute on an
agent's own authority. They pass a supervisor first. Autonomy without a gate is just an
unattended rm.
Two instances run on different machines and talk over their own trust boundary with a dedicated key, compared in constant time. One can ask the other to deploy on its behalf. The internal agent token and the peer key are deliberately different secrets — they are different trust boundaries.
A React PWA behind TOTP, reachable over a Tailscale funnel. Local-first: nothing leaves the machine it runs on. I start and steer sessions from a phone.
When agents change the code, the system rebuilds and restarts itself. A dedicated rebuild specialist handles it, behind the supervisor gate. The UI and the features shift under me while it is still running.
I added a health check and a rollback path. It still crashes intermittently under load, which is the worst kind of failure to chase — it does not reproduce on demand. Getting a live process to safely replace itself turns out not to be a weekend problem. I have not solved it.
I would rather say that plainly than describe a system that works in the diagram and not on the machine.