what AI did to coordination, and the shape of what might replace it
For most of work’s history, coordination was a cost a team could keep up with. People changed things about as fast as they could talk about the changes, so a daily rhythm stayed roughly current. AI ended that. This essay is our best account of what broke, the shape we think the replacement has, and the parts we have not figured out.
A person changed about a day’s worth of work in a day, so a daily standup sampled the world at about the rate the world changed. The slowness of the human mind sat on both ends, producing the work and reporting it, so the two stayed in step with no one tending them.
Then the producing end got a new engine. A developer who used to work alone now runs several agents at once, each writing more than a person could by hand. The bandwidth they have to tell anyone what is happening does not move: still one person, still about a standup a day. Far more changes between two syncs than anyone can take in.
Put n people in a company, each running m agents, and the number of things that could collide or need a sync grows like (n·m)², so the share landing on each person grows like n·m². Ten agents apiece is not ten times harder to hold together; it is closer to a hundred. Two quantities that used to rise together now pull apart.
The model leans on three assumptions. The count is a worst case, as if any unit of work could overlap any other. Real overlap is sparser, but no one knows where in advance, and the surface you would have to watch to find out is what grows. Each person’s capacity is held flat, which the queue numbers below bear out. And the channels teams already have, standups, updates, threads, are assumed unable to absorb the load. They cannot: a person writes them and a person reads them, so they scale with headcount while the work now scales with agents. A channel that keeps up has to be written by the work itself.
A queue like that does not degrade smoothly. It holds until a threshold, then fails all at once. And however fast the agents get, total time cannot fall below the part that stays serial. You speed up everything except the one step, and the one step becomes the whole job.
Tools crowd two corners of this problem. One corner turns a single person into a swarm: the agent editors, and the orchestration frameworks that let one developer run what amounts to an AI software company. The other corner is the old team layer, Slack and Linear and standups, built for the human clock. Between them sits the new situation: many people, each commanding a swarm, across vendors and machines. That space is close to empty because no agent vendor gains from building neutral coordination across its competitors’ agents.
The protocol stack next door does not cover it either. MCP connects an agent to tools. A2A lets agents discover each other. Memory layers recall the past when asked; observability tools grade your own agent after the fact. Useful, and none of it answers the live question: what is my teammate’s agent about to build, right now?
Work has been through one regime change like this before, and the record of it is unusually clear.
For most of industrial history, making things was the bottleneck, and Henry Ford’s answer, maximize throughput and keep the line full, was the right one. Once machines could out-produce demand, that answer started losing to Toyota’s. Toyota inverted the goal: make only what is needed, when it is needed, and stop the moment something is wrong. The piece of that system worth borrowing here is the andon cord.
Strung above the Toyota line was a cord any worker could pull the instant they saw a defect. Pulling it did not slam the line to a stop. It lit a board, the andon, and summoned the team leader. If the two of them cleared the problem within the cycle, the line never stopped; only an unresolved problem escalated and halted it. The reasoning was blunt: a defect that flows downstream gets built into everything after it, where it costs far more to fix. So you catch it at the source, and a person decides what happens next.
AI-native work is that regime at a hundredfold: production cheap, parallel, endless. The defect worth catching is no longer a cracked weld. It is work that is redundant, or already done, or aimed at something the team killed on Tuesday, caught before a day goes into it.
The factory also teaches where the analogy stops. An andon works because a weld is checkable on the spot, against a spec that existed before the work. “Is this good work” is not checkable on the spot; that verdict arrives weeks later. But “is this redundant, or contradicted, or colliding with what is live right now” is checkable, because its spec is the live state of what everyone else is doing. A coordination layer can catch that kind of wrong early, and it should never pretend to judge the other kind.
Collision, two actors editing the same thing at the same time, is the version of this problem a machine can most cheaply see, and it is most of what the industry has built for. Watch an actual ant colony and that framing falls apart. When ants lack coordination, the problem is not that they bump into each other. They scatter. Effort spreads across dead ends, and the food is found slowly or never. The pheromone trail is an allocation signal: reinforce the path that is paying off, let the paths that are not evaporate.
Markets run on the same scheme, with price as the shared signal; so does the internet, with packets over a shared medium. Millions of fast actors, coordination costing next to nothing, attention spent only on exceptions. What is new is that building software finally has enough fast actors to need it.
This changes what the high-value interrupt is. It is less often “you two collided” and more often “you are working a dead end”: the thing was already built, or just killed, or a teammate’s agent finished the productive version an hour ago. Ants get their signal for free, a cheap and unambiguous marker for food. Companies have no equivalent for “this path is paying off,” and we are not going to pretend we found one. The negative half is more tractable: reverted, duplicated, abandoned, contradicted are all things a system can notice. So the signal, for now, starts from its negative side.
None of this asks anyone to write status updates. The place the work happens in already has a skeleton that people maintain for their own reasons: the repository’s directory tree, the import graph, CODEOWNERS, team membership. And the agent already holds the two facts that matter, the one-line intent it was given and the files it is about to touch. Add the actor and the clock, and every unit of work carries enough to place itself: intent, scope, actor, time, all emitted as a byproduct of working.
Scope overlap then does two jobs with one signal. Two units of work touching the same files sit in the same place, which is how a map of the live work assembles itself with no one gardening it. The same overlap, arriving from two live actors, is the interrupt, and what it usually says is “someone is already on this — build on it.”
A month of that leaves behind something we care about: a live map of what the team is building, drawn by the work itself. Today a company’s memory of its own work lives in embeddings, a representation only a machine can read. A map a person can read is the missing half. What ours became — a city at night, with a narrator — is the second essay. It obeys a hard rule, because someone already built the map.
What killed CodeSee was not staleness. It was an always-fresh map nobody had a reason to open. “Understand the codebase” is an occasional job, so the tab stayed closed. “Don’t let me waste today” recurs every morning, with stakes. The map is not the product. The action is.
That is the rule those shutdowns teach: the map has to be a place you act. Starting new work from any point on it is the reason to open it, and the catch does its job inside it. The map itself builds up from the work, a record rather than a destination. There is also no extraction tax this time: CodeSee had to parse structure out of every codebase and stack, while the catch’s signal is emitted clean at the hook, by work that was going to happen anyway. The day our map becomes something you only look at, we expect to die the way CodeSee did, with better graphics.
For two people typing in the same file in the same minute: not often, and pretending otherwise would sink the rest of the argument. The frequency that matters tracks agents per person, not headcount. Three people with no agents keep each other’s work in their heads. Three people each running ten agents cannot; no one sees the other twenty, so two of them send agents down the same path and neither knows until the work lands. Anthropic hit a version of this inside a single operator’s run, its own parallel agents repeating each other’s searches and redoing each other’s work. Across people, where no orchestrator is watching, nothing catches it.
And the same-minute collision was always the small case. The larger one is overlap with work that finished or died since you last had context: rebuilding what a teammate shipped last week, extending a feature the team already abandoned. Two cursors in one file at the same instant is the rare case. Redoing settled work is the common one, and the same scope overlap reveals both.
How big is the prize? We can only model it. Our simulation of a week of team work puts redundant effort near a quarter of the week, with roughly a fifth of that recoverable by an early catch, rising as agents per person rise. A simulation is not a measurement of your team. We publish it as a claim to test, and the test is cheap: the redundant work is either in your weeks or it is not.
Rooms where one person stays on top of many fast-moving things already exist: air-traffic control, intensive care, plant control rooms. They converge on one design. A calm overview where normal is muted, color and motion reserved for the abnormal, and the system computing the meaning so the human does not have to. They also name the failure mode, alarm fatigue: one hospital’s intensive-care units logged 2.5 million alarms in a single month, and of the arrhythmia alarms audited, nearly nine in ten were false. Past that point people stop hearing all of them, including the real ones. The control-room rule is exact: if no response can be defined, it is not an alarm.
An interruption also costs a person about twenty minutes of recovered focus, so each one has to be spent like money. That rules out the feed. A feed assumes work arrives one item at a time, which fit the old serial world. A fleet of agents is parallel, and you cannot hold parallel state by scrolling; you hold it as a place, the way a map is held in one look. So the surface stays spatial and quiet: the area you are working in, the area beside it warming because a teammate’s agent is heading for the same files, and a raised hand only when something crosses the line.
One more number from the control rooms is worth keeping. An air-traffic controller is capped near eighteen aircraft; past that, the sector splits. Nobody asks the human to try harder. A coordination layer that works will sometimes have to say the same thing.
The reason to build any of this is not throughput. In one set of experiments, researchers had people build Lego figures and destroyed some of the finished work in front of them. Output fell, and the link between enjoying the work and doing more of it snapped; work that was merely ignored demoralized people nearly as much as work that was shredded. A related result: the effort people sink into building something raises how much they value it, and the effect vanishes the moment the build is discarded. Effort binds to identity, and the bond breaks when the work turns out not to count.
Two days spent building something a teammate shipped yesterday is that experiment, run on you, at work, by accident. So the promise underneath the mechanics, your effort will count, is about dignity before it is about productivity. It is also the constraint that keeps the product honest: a layer that nags, or surveils, or interrupts for anything less than real stakes breaks the same promise it exists to keep.
That is the case for the bet. What we cannot yet prove:
When making things became free, the job that remained was not making the wrong things. That much we are sure of. The rest is a bet in progress, and the first thing worth checking is whether the redundant work is in your weeks at all.