Most agent systems are built for people who already know how they work. The vocabulary assumes you’ve followed the field; the tools assume you can read the code. If you haven’t and can’t, you’re expected to wait. This is written for the rest of us — and for the engineers who’d rather build something a non-engineer can actually trust.
I’ve tried many paths to building agents, their harnesses, and the systems that watch and govern them. Each major model release brought new reach and new capabilities, and each one forced a refit. More than once it made hard-won work redundant overnight. No one needs telling how fast the field has moved, and no one forecasts it without hedging. As an engineer, I enjoy these waters. I spend my time on things I could not have built a few years ago, and on understanding why they work.
To artists, engineers, and most creative people I know, process matters as much as product. I struggled at first working with multiple models. I felt a loss of control and had little visibility into the final outcome. I gave myself real headaches trying to follow, line by line, the work of a small agent team building my first multi-agent hub. As the models progressed, things became clearer — or I learned to “speak agent” — and I settled into patterns that gave me confidence in the shape of my codebases. Along the way the top models took a significant step up in capability, and the rough spots I had been fighting smoothed out almost overnight. I began dreaming of bigger projects, with more complexity than any one person could deliver.
What the dreaming taught me was that the limit was never the code. It was the process around it — and the process had no tools. The real shift isn’t that AI writes code faster. It’s that agentic systems — software that can plan, act, check its own work and ask for help — are ready to work on more than code. They can look at how the work gets done.
This is unmapped country, and the maps we have are for a different one. The tools we need examine, measure and improve the process itself, not just the code.
So the question for most organizations isn’t how to add these systems to what they already run. It’s how to reorganize around what they make possible.
Loops and Factories
Two patterns dominate the field right now. A software factory is an assembly line for code: agents produce, test, package and ship, and the human inspects at the end. Loop control is the rule set inside a single agent — think, act, check, stop — that keeps it cycling until a condition is met. Both are new, both work, and both are good at what they were built for: volume and repeatability.
What they share is an assumption: that the process is already known. A loop can retry a failed step a hundred times. It cannot ask whether the step belonged in the process at all.
We build the other way round. Instead of stages, we have roles. The one that matters most is the XO — the executive officer, the agent that runs the crew so the Captain can judge the ship. The XO keeps the work moving: it assigns the next job before a seat goes idle, measures what comes back, and brings the Captain only the decisions that are the Captain’s to make. It is also the one watching the process itself — where the turns went, what cost the most hands, which gate caught nothing — and it reports that and proposes the change. The Captain rules; the XO is where the proposals come from.
But the XO is a convenience, not a gate. The whole crew works on one shared thread the Captain reads and can post to directly, and a Captain’s word on that thread outranks the XO’s. Over time my XO has learned what I want to hear and when, and what I struggle with, and keeps that as a record it corrects every time I push back. The process adapts to the person running it — and the person can always step past it.
Because everyone works on one thread, nobody works alone: a builder’s doubt is the reviewer’s cue, a reviewer’s finding is the next order, and a direction can be tried in the open and abandoned by lunch. A factory optimizes the path it was given. A crew on a thread can ask whether it’s the right path.
On a pipeline, each stage sees only what the last one handed it. On a thread, every seat sees the whole: the builder’s doubt, the reviewer’s finding, the Captain’s hesitation. That is what makes it possible to change direction — not by rebuilding the line, but by saying so, where everyone can hear it.
The thread is the room. In a room, a team can disagree, try two directions and keep the one that holds. A pipeline can’t do that; it can only run faster.