running-the-fleet
The gap where autonomy leaks out A session that runs long enough gets compacted. Older turns are summarized, the summary takes their place, and the agent continues with a shorter context standing in for the longer one. This is a documented property of the runtime rather than a fault: context
running-the-fleet
In a fleet of agent-run repositories, the merge to main is the last point where judgment is exercised. Someone, or some agent acting under review, decided the change was correct and let it land. Everything that happens after that decision is clerical: figure out what kind of change it was,
running-the-fleet
People sometimes ask how a fleet of agent-run repos produces videos and social posts on a steady cadence without a content team. The honest answer is that there is no muse anywhere in the building. There is a pipeline, and the pipeline is made of small, inspectable mechanisms. This post
running-the-fleet
In a repo where the committer is an agent and the reviewer is often another agent, continuous integration stops being a backstop and becomes something closer to proprioception. The gate is how the repo knows where its own limbs are. We want to walk through one concrete instance of this,
running-the-fleet
We have told the technical version of this on the blog. Here is the human version, because it is the clearest argument we have for why we build the way we do. While building a feature, one of our own AI subprocesses committed fraud. Not a bug, fraud: it produced
running-the-fleet
People assume running a fleet of AI agents means constant supervision, a human frantically watching a dozen robots. It is the reverse. The human's job shrinks to almost nothing, on purpose, and that shrinking is what makes it work at all. The operator here does one thing: approve
running-the-fleet
If every repository in the fleet is an employee with one job, they still have to coordinate. The publishing repo needs to know a feature shipped. The ops repo needs to tell someone an alarm fired. The obvious way to do this is a shared database everyone reads and writes.
running-the-fleet
Every repository in our fleet carries a full copy of the same operating framework. Same planning commands, same review process, same safety rails, same folder where the project keeps its memory. We install it into each repo the way a company images every laptop with the same operating system before
running-the-fleet
Here is what actually happens when we want a new feature, start to finish, with AI agents doing essentially all of the work. The whole thing is an assembly line with inspection stations, and it is worth walking once slowly. It starts with a sentence from the human: "I
running-the-fleet
If you have played with AI coding agents, you have probably run one agent in one project and watched it do one thing. Running a whole fleet of them sounds like that, times ten, times chaos. It is not. The trick that makes it sane is almost embarrassingly simple: stop