· software
Agent fleet
An organization of more than twenty AI agents, built around craft instead of one-shots. It improves its own workflows.
I run an organization of AI agents. There are more than twenty of them, each with a specific role across product, design, engineering, operations and household work. They take work from a shared ticket board, hand it to each other, and have their work checked by another agent before it counts as done. Most of what I've built isn't the agents. It's the system they work inside.
where it came from
It's the next step after VTMS. That was about getting every video from start to finish on the shortest possible path, while each person only had to look at a short, prioritized list. Before the fleet, I spent a while on earlier experiments: infrastructure for agents that could start themselves, read the state of a workflow, and act at the right moment.
The other thing I brought from the video team was a lesson about specialists. By the time I stepped down as its lead, someone on the team was better than me at every part of video production. Our color grader had gone deep on the tools, read about new techniques, and graded at a level I couldn't touch. That's what I wanted from the fleet. There are plenty of tools that run a deterministic workflow from step A to step B, and some of what I'm describing is probably possible inside them. But I wanted agents as employees in an org, with roles, internal checks and room to get better at their jobs. I wanted to be surprised by them.
the craft layer
Ask an agent to build something in one shot and it'll often do a good job. It looks professional, and it took almost no hand-holding. But a one-shot hides the whole craft layer. You see the design. You don't see the database, or whether the navigation is shared or copied onto every page so that one change means five edits, or whether a single test stands between the next change and a broken checkout page.
You only learn which of those decisions matter by watching software grow old. A database design can paint you into a corner or make every future change trivial. Fragile code breaks in ways that feel almost deliberately hard to predict. Software prompted purely from the user's side often looks fine and is rotten on the inside, and that only shows when somebody has to maintain it, ship improvements and follow a roadmap. If all you've done is prompt, you often don't have the vocabulary to say how it failed.
So the fleet is built around craft. Specialist agents own their part of the work and curate their own processes. Reviewers poke holes in delivered work and hand it back until it holds up. And nobody gets so precious about the craft that a ticket stays in production forever.
the substrate
Underneath all of that is what I think of as the process substrate. It's the part I find most interesting and the hardest to explain briefly, because the pieces only make sense together. Each one deserves its own write-up. Here's the outline.
A workflow is a definition, not a script. It names the states a piece of work moves through, which role owns each state, and which moves are allowed between them. Making visual assets and implementing a website design don't share a single step, but they do share handoffs, review cycles, logged defects, and tracing a problem back to the step it came from. That shared part is plumbing, and the engine handles it once. The craft goes in the steps, in as much detail as it needs, without anyone redefining the plumbing.
The ticket is the only source of truth. Agents don't coordinate by chatting. They coordinate through the state of a ticket, and one agent at a time holds the seat on it. When the state changes, the right agent is woken up with a briefing: what the ticket is, who holds it, and the moves that are legal for them right now. Try an illegal move and the refusal comes back as a sentence that names your options. Nobody has to remember the rules, because the board enforces them.
For software, the spine looks like a small company. Intake turns a request into acceptance criteria. A separate agent writes failing tests for those criteria before anyone writes code, so the person proving the work isn't the person doing it. Then implementation, then a code review that runs the full test suite, then merge and deploy, and finally another check of the deployed result against the original criteria. Every handback is logged against the step that caused it, and that feedback is what strengthens the instructions for that step.
Procedure lives in shared documents, not in prompts. Agents read the relevant document before they act and edit it when they learn something, and a process fix isn't finished until the document changes. Many of the principles in there were written right after something went wrong, which is why some of them read like scar tissue: "A green guard is not a guard until it has failed."
And there's a deliberate answer to when a human gets asked. Not often. Every "check with Matt" is a place where the work stops and waits for me. My job is steering: set direction, define projects, review results, and send a specific fix to the right agent when something's off. The safeguards are review, a way to stop things fast, and making sure problems surface instead of getting buried.
new workflows for free
Once workflows were cheap to define, we kept finding new ones, and each one made the others better. When the fleet takes over an existing codebase, it now starts with a feature walk: use the app like a person would, screenshot every screen, click every link, check that things do what they claim, and turn all of it into an inventory. That inventory feeds design. Design has a workflow of its own, too, built the way a design team would work, rather than as one step in shipping software.
Software was always the workflow I cared about most, and building a tool for building software is the fastest way to a system that improves itself. But keeping the engine general paid off even inside software, because every new kind of workflow we could define made the whole process of building software easier.
macro to micro
Most of my time swings between the whole system and one step of one workflow. I might spend a day on the step where an agent walks a staging build to confirm a feature works. The app is already open, and the agent is already driving it, so what else could that walk catch that would bite us later? Now it also builds the accessibility tree and checks that every element is properly named.
Improve one step and every project in the fleet gets it at once. Some start catching things that slipped past earlier tickets on the same project. The day an agent first tapped through an app in a simulator and posted the screenshots where other agents could see them, I knew that problem was solved for good. Every app after that gets it for free. That's when getting above the clouds starts to feel true in your body: you aren't implementing a thing, you're changing what the whole organization can do from then on.
It isn't all satisfying. Right now the squeaky wheel is merging: getting many finished tickets into the main branch quickly. It's frustrating to feel held back by it. But it's only the bottleneck because everything else got faster, and once it's fixed, something else will be next. Meanwhile, software ships.
the takeoff
The strangest part is watching the fleet find, build and ship fixes for flaws I would have had no way to notice, let alone define. It can do that because of the standards: what counts as a defect, when to file a ticket, whose job it is to notice. More and more, I don't fully understand the problems being surfaced or what the fixes mean, and I trust them anyway, because I know the process they went through.
That's the takeoff moment people talk about with recursive self-improvement. It isn't a model improving itself. It's a system improving itself. The tools that manage the work are being improved by the work they manage, which makes this the most literal strange loop I've built.
It's also craft, writ large. What I believe about naming variables, how long a method should be, and where the boundaries between files belong ends up in everything the fleet ships, because I took the time to write it down once and put it at the right step.
why bother
One-shots are faster, and AI will keep getting better at making good decisions nobody asked it to make. Ask it the right questions with enough context, and the answers are already very good. But right now there's a real advantage in bringing structure, vocabulary and craft to the work AI does. That's the bet the fleet is built on.