How to work with many agents

It is common now to meet a developer running ten coding agents at once, and the striking thing is where the work actually happens: in their head. They track what each agent is doing, hold how the pieces will fit together, and decide constantly, while the agents generate. The arrangement is genuinely productive at ten agents, and it cannot survive at a hundred, because the integration living in the person’s head grows much faster than the agent count.

The ceiling has been measured before, in people. In 1933 a management consultant named V. A. Graicunas took up a question practitioners felt but could not explain: why does an executive with four subordinates hesitate to add a fifth? He answered it by counting what a supervisor actually tracks, which is not four things but four people, every pairing among them, and each person’s view of the rest. Four subordinates put 44 relationships on the supervisor. A fifth raises the count to 100: twenty percent more hands, more than double the tangle. That arithmetic is why spans of control settled near five in every organization that studied them, and a person integrating the work of ten agents in their head is running the same arithmetic on the same head.

We run our own fleets at the lab, and two mental models carry all of it. The first: hold macrostates, not microstates. The person states what must be true about the outcome, and the system owns every route to it. The second: however far the work diverges, it converges into one trunk, and human judgment operates at the point of convergence. Neither is a management tip. Both are facts about computation, about what search is and where information comes from, which is why they keep working from ten agents to a thousand.

Macrostates

The first model replaces the question “what should the agents do” with “what must be true when they are done.” The difference shows in two briefs for the same task, a slow endpoint. One brief reads like a plan: open src/api/products.ts, wrap the database call in lru-cache, invalidate on the write path, follow the pattern in search.ts. The other reads like a contract: the tests pass, /products answers a warm request in under 100 milliseconds, and the diff adds no new dependency.

The plan is the natural brief for someone who used to do the work themselves, and it fails in two quiet ways. It makes decisions before the search starts: lru-cache is settled in advance, even though the contract version of the same task forbids new dependencies entirely. And its author is the only one who can verify it, since only the author knows whether the route is being followed. Verification that requires the author’s presence is watching under another name. The contract has neither failure. Anyone, human or script, can check its three lines without having seen any of the work.

Statistical mechanics supplies the right names for this distinction. A microstate is one exact configuration of a system; a macrostate is the set of configurations that share the properties that matter. Thermodynamics operates entirely on macrostates, measuring the gas and never the molecules, and loses nothing by it. An acceptance condition is a macrostate: it pins properties of the outcome and says nothing about which configuration delivers them. The silence is what scales. Twenty acceptance conditions fit in a head that could never hold twenty routes, and the routes were never the point.

Conditions fail at two extremes. Too tight, and the condition is a route again: a person editing an agent’s output word by word has delegated nothing. Too loose, and it constrains nothing: “make it good” admits every output under some reading, and a search under a condition that excludes nothing is a random walk. Conditions that work pin properties and ignore configurations:

• The build passes.
• Every claim carries a source.
• The page loads in under a second.
• No written rule is violated.

A stranger could check each of those, which is the working test: any condition whose verification requires having watched the run is a route wearing a condition’s clothes.

Amortized mistakes

Micromanagement, in this vocabulary, is attention spent on microstates, and the most tempting microstate is the visible mistake. An agent searches src/ for a file that lives in packages/. The error is obvious to anyone who knows the codebase, the correction costs a sentence, and the detour costs the agent about two minutes. At one agent the correction looks free. At twenty, the two costs sit in different economies: the detour costs compute, which multiplies with the fleet, while the correction costs attention, which does not. Interruption research prices the return from a context switch at over twenty minutes, ten times the detour it prevents. A person who corrects every visible deviation has rebuilt the five-agent ceiling inside the larger fleet.

Non-intervention works because a wrong route usually announces itself to the agent that took it. The search returns empty, the test fails, the fetched page lacks what was expected, and the failure enters the next attempt as information. Search that does not tire describes this loop as a search that retries at the price of a model call. Most deviations resolve within minutes, so their cost amortizes across the fleet, while every interruption bills the one resource that has no fleet.

Two kinds of mistake escape the amortization argument. The repeated mistake escapes because model calls are stateless: an agent repeating yesterday’s error is reporting that the system never fed the correction back, and the durable fix is a macrostate-level fix, in a form every future run inherits:

• A written rule. The correction, generalized into an instruction that every future run reads before it starts.
• An automated check. Where the rule is machine-checkable, an audit that fails the work on violation with nobody present.
• A boundary. A limit on what a run may touch, spend, or send, so the mistake becomes impossible to express rather than merely discouraged.

Encoding judgment as rules traces that pipeline, and its economics reduce to one line: watching bills on every recurrence, encoding bills once. The structural mistake escapes for the opposite reason, because it lives above the runs: a wrong decomposition or a wrong acceptance condition corrupts everything downstream, and downstream cannot repair it. Mistakes inside the work amortize. Mistakes in the arrangement of the work compound, and those get corrected the moment they appear.

Explored space

The second model begins with why divergence pays at all, since fanning four agents across one problem looks wasteful next to writing one better prompt. The computational answer: a model samples each token from a distribution conditioned on its context, and a prompt can only shift that distribution. It cannot add information that does not exist. “Weigh the alternatives carefully” cannot supply what happened when the alternatives ran, because nothing has run. Evidence of that kind comes into existence only when something goes and gets it.

Four agents sent into four regions of a problem return with what the regions contained: the approach that failed with its error text, the source with its actual claims, the measurement with its value. A synthesis over those reports samples from a distribution moved by evidence no single run could have held, which is the same reason four people who each checked a different store beat one person reasoning about inventory from home. Our operating log states the bet: “20 agents running in different directions collecting data about the world is going to be far superior to one human.”

Monty Hall is the textbook picture of conditioning on revealed information. A contestant picks one of three doors; the host, who knows the prize and never opens its door, opens a losing one, and switching now wins two times in three, though the first pick never got worse. A constrained process revealed information, and the winning move conditions on it. A synthesis agent reading exploration reports is the contestant after the door opens.

The analogy breaks in one place, and the break defines a discipline. The host cannot lie; an agent can, without meaning to. A confident report from a region never visited moves the synthesis distribution exactly as an honest one would, and makes the answer sharper without making it truer. Reports therefore carry receipts:

• Tool output over recollection. A claim about a system arrives with the command and its output attached, not the run’s memory of having tried it.
• Sources over summaries. A claim about the world arrives with the fetched document, so the synthesis conditions on what the source says.
• Tests over assurances. A claim that something works arrives with the passing test. “It works” is a prediction; a test result is an observation.

Receipts narrow the room for invented evidence without closing it; a mechanism that closes it has not appeared yet. The shape itself is proven well beyond agents. MapReduce spread computation across machines and combined it in a reduce step, and best-of-N sampling spreads generation across attempts and keeps the winner. In every version, the combining step is worth exactly what the spreading step touched.

Convergence

Divergence, however wide, ends in one place. That is the second model in full: value realizes only when branches fold back into a single trunk, the one current version of the thing under construction, and the fold is where human judgment belongs. Git made the shape familiar. A coding agent checks out a branch, works alone, and returns a pull request, and nothing it did counts until the merge. Shipping is merging works out the economics: branches became nearly free, merging did not, so the queue forms at the merge, and the person belongs at the front of it, because the merge is the one place where taste compounds.

One of the businesses the lab runs delivers crafted video, and its generation fleet produces dozens of incomplete branches, each trying a different structure. The human work there begins at convergence: selecting the pieces that survive judgment, handing the survivors to an agent that stitches them into a single composition, then a denoising loop that regenerates whatever reads wrong until nothing does. No human writes a frame. The finished piece consists entirely of selections.

The merge runs one branch at a time, because each admission changes the trunk, and a judgment made against the current trunk is the only kind that stays correct. Mechanical checks run before human eyes, so what reaches judgment is exactly what no rule can decide yet, which is taste. And nothing merges unreviewed, because a pile of unjudged branches is accumulation that feels like progress: bulk-merged, it pushes unjudged work into the trunk, and every future branch inherits it. A fleet that generates ten candidates and promotes winners under a stated condition improves every round. A fleet that keeps everything has produced reading.

Takeaways

The two models, with what falls out of each:

• Macrostates, not microstates. The person states what must be true in a form a stranger can check, and the system owns every route.
• Mistakes amortize. Deviations self-correct at the price of compute, which multiplies; only repetition and structural errors escalate, and repetition escalates into rules, not into watching.
• Explored space conditions the answer. A prompt shifts a distribution; exploration moves it with evidence that did not exist before, and receipts keep the evidence honest.
• Everything converges to one trunk. Branches multiply freely, checks judge them first, and human taste admits them one at a time at the merge.

The two models place the person in exactly two moments: before the work, stating what must be true, and after it, judging what returns. Both moments scale with the number of deliverables rather than the number of agents, which is the entire scaling law. The day keeps its shape while the fleet grows an order of magnitude.

One asymmetry compounds in the background. Every repeated mistake becomes a rule, every rule outlives the run that taught it, and each pass starts where the last one ended. The fleet nobody watches gets harder to derail the longer it runs.

The whole method fits in a sentence: the person states what must be true, the fleet diverges to explore, small mistakes amortize where they happen, and judgment arrives at the merge, so attention stays free at any fleet size.