This isn't just about this website. A real and growing share of my company's operations runs this way. A
fleet of AI agents I built sends the work out, has each result checked by another agent, and
brings me the calls a human still has to make. Here's the stack, what broke, and what each
failure taught.
The stack
the real systems, not a vision deck
This isn't a someday-architecture. It's the actual set of systems running the company right now —
built, run, and watched by one fleet of agents. Here's how they fit, then what each one is for.
Auto-verified against my internal repo catalog — 11 systems, last checked 2026-07-21.
Tap to open the full map.
Firstmate
the dev loop
Why
Running more than one coding agent turns into tab-juggling — babysitting sessions and carrying context between them by hand.
What
The single agent I talk to. It runs a crew of agents for me and hands back finished pull requests.
How
It spawns one worker per task, each in its own isolated copy of the repo, supervises them to done, and brings me only the calls that need a human. A scope that never ends gets a persistent second mate — a standing coordinator that runs its own crew underneath.
Cody
the dev loop
Why
Every pull request needs a reviewer that never gets tired or rushed.
What
A self-owned AI code reviewer that reads every PR across all my repos.
How
It learns from a commercial reviewer's feedback, distills its own rules, and holds the merge until they pass.
Portal
product
Why
Patients and front-desk staff were stuck with clunky, disconnected tools.
What
The patient and front-desk app — registration, scheduling, messaging, tasks.
How
One surface over the clinic’s real systems, so a patient self-registers and the work lands where staff already look.
Chart Review
product
Why
Charts must be complete and accurate — but reviewing them by hand burns the providers I want to protect.
What
An engine that reads every chart for completeness across clinical domains.
How
AI drafts the review, a clinical gate checks it, and only what genuinely needs a human reaches one.
Billing / RCM
product
Why
Revenue-cycle work is where clinics quietly leak money — to manual keying, missed eligibility, and mistakes.
What
Runs insurance eligibility checks, and reads statements, invoices, and cards into clean structured data.
How
Verify coverage up front, then extract and reconcile-or-refuse — only numbers that tie to the source ship; the rest routes to a human.
CFO + COO engines
the brains
Why
You can't run a business on gut — you need real P&L and real operations numbers.
What
Two engines — one for finance, one for operations — that compute the picture from raw data.
How
Both write to one canonical ledger; the brains I actually talk to read from it, so every number has a single source.
HUD — Mission Control
mission control
Why
I need to see the whole company at a glance, not log into ten separate tools.
What
One executive dashboard over every system and number.
How
It reads the canonical ledger and each product’s signals into a single pane.
The fleet + memory
substrate
Why
Agents that forget everything between sessions can't be trusted with real work.
What
A fleet of coordinating AI agents with one durable, shared memory.
How
They verify each other’s work, and everything load-bearing is written to a knowledge base any agent can resume from — this site included.
How the stack has grown
This log writes itself — a scan of my repo catalog logs every system added or retired, so the
progression is real, not remembered.
2026-07-03First snapshot of the stack — 11 systems.+ agents-flow, arcs-chart-review, arcs-doc-extract, arcs-extract, arcs-financials, arcs-lattice, arcs-managed-agents, arcs-studio, Card-OCR, cody, Portal
● The build log
How the system actually got built
From one terminal and a notes folder to a fleet of agents that check each other's
work. Every step was forced by something breaking. Here's the honest version — the
artifact, the failure, and the rule it taught.
Early 2026 — One terminal
One Claude Code session and an Obsidian vault. Everything ad-hoc, everything by hand.
The lesson The question was never "can one agent help me." It was "what breaks when I add the second one." Coordination is the whole game.
Spring 2026 — A fleet on tmux
Agent work fought my dev machine, so I moved it onto dedicated boxes — cheap $271 mini-PCs — and wired a boss session to its peers over tmux with a small message helper.
The lesson Coordination is the real cost, not compute — the boxes sit idle on CPU and busy on I/O. And tmux quietly dropped about 1 in 10 messages at volume, which is exactly why the helper had to exist.
Late spring 2026 — A real dispatch engine
Hand-run orchestration was too fragile, so it became a proper conductor: a dispatch API, a job graph, a worker pool that takes an issue and ships a reviewed pull request.
The lesson A merged PR is not live code. Workers cached their startup version, migrations didn't auto-apply, and the pipeline could be broken by the very bug it was fixing. Verify the running artifact, never the paper trail.
June 2026 — The "nation" (the pivot I simplified)
I organized the fleet like a government — a president, governors, a written charter, terms of office. Literal bills and votes.
The lesson The honest one. The ceremony grew faster than the engineering. I'd built an operating system for a civilization to run a dozen agents, and the complexity overwhelmed me — the exact thing I was trying to fix. I kept the engineering and threw the metaphor away. A persona shapes behavior; it doesn't add competence.
June 2026 — The reality gate
I built a system in dozens of modules, every unit green, mutation-tested, reviewed sound. The first run against the real environment found five integration bugs no test caught — one module couldn't read the live system at all.
The lesson Green on mocks is never done. Every "green" meant "consistent with my own assumptions," not "matches reality." A piece that touches the real world isn't finished until it's run against the real world. The most transferable rule I have.
June 2026 — Self-healing
A box died under its own load three times in one day. Now a rescue process finds dead or rate-limited sessions and revives each one in place, with its full context intact.
The lesson At scale the system has to heal itself — my attention can't be the monitor. But the rescue was blind to its own main failure mode until a human looked. Automation still needs one human-eyes rung.
July 2026 — The thin waist
A dispatch engine in the middle, a thin layer that gates and merges and watches health, and agents that do the disposable work on a cheaper model while the frontier model is saved for judgment.
The lesson Right-size everything. A handful of long-lived agents per box; everything else is throwaway. The system that survived is the one I can hold in my head.
Now — Firstmate: one conversation, a whole crew
All of it collapsed into a single harness. I talk to one agent — the first mate — and it runs the crew: a worker per task, each in its own throwaway copy of the repo, supervised to done and handed back as a finished pull request. Scopes that never end get a persistent second mate, a standing coordinator that runs its own crew underneath.
The lesson The interface was the bottleneck, not the agents. The moment there was exactly one seat I talk to, everything below it stopped being my problem — which is the entire point. Any worker I have to name by hand is a layer that hasn't been finished yet.
● the fun part
Wait — who actually built this site?
Mostly not me. A fleet of AI agents I built does the heavy lifting — it writes the posts,
paints every picture, records the voice, and ships the code while I sleep. I just point and
review. Don't take my word for it. Here's the receipts.
↓ every tile is AI-made — click any one to read the post it illustrates
