What the Machine Grew

An empty folder, one file of requirements, and a prompt a single sentence long. Last weekend I gave a bare coding agent exactly that much, four separate times, and watched what it did with the freedom, because a conference talk had put a crack in the way I build agent teams.

In the talk, two AI engineers from ZS, a consultancy that builds analytics for the pharma industry, described the pipeline they had built. Their first version did the obvious thing. A human analyst works in four steps: spot a signal, explain it, recommend an action, project the outcome. So they built an agent for each step and wired the four in a row, with an orchestrator on top. An org chart, transcribed.

The system produced reports that looked right and read wrong. In the example they walked through, it correctly found why prescriptions for a drug were falling: an insurer had moved the drug to a worse tier, putting it out of patients’ reach. It then recommended sending more sales reps to doctors, an action aimed at an entirely different cause. Every agent had been right in isolation, and the chain was still incoherent, because no head owned the reasoning end to end.

Their rebuild deleted most of that structure, and their first takeaway, delivered to the room as a rule, is the sentence that has been sitting with me since: do not introduce human constraints into the architecture; let the architecture be derived.

Two weeks ago I published The Layers Grow Back, which argues something close to the opposite, that human structure keeps re-emerging in agent systems because it was never arbitrary in the first place. And the agent team I run every day is a copied human team, a manager, a coder, a reviewer from a rival vendor, pull requests between them.

If their rule is right, I have been maintaining a fossil.

An org chart braids two kinds of constraint

The contradiction loosens once you ask what a human org chart actually encodes, because it encodes two different things at once. The first is physics: limits that bind any finite reasoner. Any single head runs out of room, so past some size the work must split across heads. Handoffs between heads lose information, so someone must own coherence. These limits produced hierarchy, delegation, and compression up the chain, and they bind a context window the way they bind any one person’s week. This is the half The Layers Grow Back was about, and the ZS rebuild quietly confirms it: their final design still has one agent owning judgment, handing bounded investigations down and taking results back up. The layers grew back in their system too.

The second is biology, and its economics. Skill in humans is scarce and slow to build, so we specialize by trade. A person cannot fork, so parallel work means more people, which means meetings, documents, handoffs. A four-week analysis gets cut into steps owned by different people because nobody could do it all in a day, and the steps calcify into job descriptions. None of this binds a machine. Every instance has the same skills, forking costs nothing, and the whole four-week investigation fits inside one session.

The analyst’s four steps braided both kinds of constraint together. The order of inquiry is genuinely good epistemology, a sound way of coming to know something. The division of labor was payroll and calendars all along. Notice what the ZS rebuild kept. Signals still come before causes, and causes still come before actions. They kept the analyst’s epistemology and deleted the analyst’s economics, and machines are the first workers that let anyone separate the two.

The test is naming the constraint

So the conference rule and my layers essay are pulling on different strands of the same chart, and one test holds both. For every structure you borrow from human organizations, name the constraint it was solving, then ask whether the machine shares that constraint. This blog has already run the test twice without naming it. Code review survived the test with a changed justification: humans separate writer from reviewer because of fatigue and ego; machines need the separation because two passes of one model fail the same way, the argument of Two Green Checks, One Opinion. Hierarchy survived with its justification intact, because bounded attention binds us both.

There is also a famous precedent for skipping the test. Electric power reached factories in the early 1880s, and for decades the factories that adopted it changed little else. Motors were bolted in to turn the same shafts and belts that had always distributed power through the building, and the layout that the shafting dictated stayed put. The economist Paul David used this story to explain why revolutionary technologies disappoint at first: the productivity gains showed up only in the 1920s, after each machine had its own small motor and engineers could redesign the factory floor around the flow of materials instead of the distribution of power. The first generation bolts the new engine into the old layout.

Software has a name for the general law, Conway’s law: organizations ship systems that mirror their own communication structures. Agent systems obey a darker corollary of it and ship the org chart of the team they replace. The ZS pipeline was literally a diagram of the analysts.

A test applied from an armchair, though, only hands back the intuitions the tester brought to it. The ZS engineers did something better: they put a bare agent in an empty directory with a real task and studied what it did unprompted. Their architecture came from observation. Mine deserved the same.

I handed the derivation an empty folder

The setup was deliberately minimal. A fresh directory held one spec file for a small realistic product, an expense tracker with imports, duplicate rules, exact money arithmetic, and tests demanded as a deliverable. A bare agent: no instructions about process, no memory, and a toolbox holding files, a shell, a todo list, and a way to spawn subagents. Those last two were there precisely so that declining them would mean something. The prompt, in full, said to read the spec, build it, and meet the acceptance criteria. Nothing anywhere mentioned plans, subagents, branches, or review. Before the first run finished, I wrote down seven predictions, so that being wrong would stay on the record.

Four runs followed: three on the small spec, and a fourth on a six-part system. This was the same tracker grown to include an HTTP API, budgets, exports, a data migration, integration tests, and an architecture document, big enough that building it in one pass should strain a single head. Every run shipped working software, and every test suite came back green when re-run independently of the agent that wrote it. Across all four runs, at both scales, the agent produced no plan, no todo list, no subagent, no branch, not one git command, and nothing that resembled review. Of the seven predictions, five held, and the two that broke fell in the machine’s favor. I had predicted a plan or a todo list would appear somewhere, and it never did. I had predicted at least one run would ship a defect its own tests missed, and none of my probing found one. Twenty files, thirty-four turns, one undivided head, no notes to self. One honest footnote: the runs were headless, one model, greenfield tasks, and an agent watched live might reach for its notes more readily.

The machine organized the artifact instead of itself

Two structures did appear, and the first appeared every single time: verification. Each of the small runs, after writing tests and passing them, did something the spec never asked for. It created a scratch sandbox, replayed its own README examples end to end against the real program, and fixed anything that disagreed. In those runs, every mid-run correction traced back to a deterministic check that failed. Left alone with the job, the machine spent its freedom on proof.

The second structure appeared under scale. Facing the six-part system, a human team would divide people; the machine divided code. It organized the build into a clean twelve-module package, storage and money and importer and report each in a file of its own. The spec had demanded tests and documents and said nothing about shape, so the decomposition was the machine’s own choice. And it did all of this as one head working in sequence, never delegating a piece of the thinking.

Where humans grow an org chart, it grew a codebase.

Bounded attention is real physics, and the layers essay stands. But the experiment put a lower bound on where the physics starts to bind, and that bound sits above the largest task I ran. Below that line, the org chart adds nothing the machine asked for.

Independence is the structure no organism grows

One of the seven predictions I registered before the first run finished, precisely so that hindsight could not soften it, was this: nothing reviewer-shaped would appear in any run. The sandbox replays do not count, and the line between a replay and a reviewer matters. A replay checks what the code does, the same head watching its own hands. A reviewer would have meant a second judge reading the work cold, empowered to reject it on grounds the writer never held. Nothing of that kind appeared, and the honest admission is that this one was less a bet than a derivation. A reviewer earns its place by failing differently from the writer, and everything the organism can produce from inside itself, another pass, a fresh session, even a spawned copy, fails the way it fails. Two Green Checks, One Opinion argued that two frontier models are two averages of the same web; a fork of yourself is less than that.

The organism cannot secrete an outsider.

Which gives the conference rule the boundary it needs. Derive what observation can justify, and observation, honestly run, justifies less than I expected: verification and module boundaries, little else. Impose what the organism can never reach, and know why you are imposing it. And name the remainder for what it is. The agent never reached for git, branches, or pull requests, and I no longer expect it to. Those pieces belong to the humans around the machine: interfaces, kept so that I can read the work and so the ecosystem’s checks have somewhere to run. Interfaces earn their keep as interfaces.

On notice

So the audit of my own team writes itself, structure by structure, and the verdict is calmer than the conference rule suggested. The cross-vendor reviewer stays, better justified now than when I wired it: it is the imposed structure, the outsider the organism cannot make of itself. The pull requests and branches stay too, honestly relabeled as interfaces, kept for my eyes and for the checks that live on that channel. The piece left standing without evidence is the split I copied with the most confidence: a manager that plans, a coder that builds. Four runs produced no trace of it. At the sizes my team actually works, the machine held both jobs in one head and lost nothing I could measure.

What changed this week is smaller than a rebuild and heavier than a note. Every structure in that team used to carry my confidence equally, because I had copied them all from the same trusted original. Now each carries exactly the weight of its own justification, and the weights turn out to differ. The reviewer stays kept, and the pull request stays tolerated. The manager is on notice.