Summary: A software dark factory looks, at first glance, like a bigger version of the neural networks inside the agents that it runs— stages feeding stages. The truer analogy is stranger and more useful: the factory has the same cognitive architecture that researchers recently found emerging inside language models, with one inversion. Inside a model, the workspace where deliberate thinking happens is hidden, and illuminating it took new science. In the factory, we built that workspace on the outside — in plain text, on disk, where anyone can see it.
A tempting analogy
If you know how a large language model works, the dark factory might give you a feeling of déjà vu.
A transformer — the architecture under every modern LLM — is comprised of layers. Each layer receives a representation from the one before it, transforms it, and passes it on. Researchers who probe these stacks find a rough division of labor: early layers read, parsing whatever arrives — English, Python, even Base64 — into an internal representation; middle layers do something like abstract reasoning over it; late layers write, translating the result back out. There is nothing but the stack: representation in, transformation, representation out, dozens of times, until an answer emerges.
Now look at the factory. Stations in a line, each receiving artifacts from the one before, transforming them, passing them on. A seed goes in one end; working code comes out the other. It’s hard not to see it as the same mechanism at a larger scale — as though the layer stack had continued past the edge of the model and out into the world.
The analogy is tempting, and it’s about one-third right. The interesting part is where it breaks — because each break explains a design decision that would otherwise look arbitrary. And those design decisions are the ones a regulator, an auditor, or an investor will eventually ask someone to defend.
Where it breaks, and why the breaks matter
First break: within a single pass, a transformer only runs forward. Layer 40 never sends anything back to layer 12 — “time” is measured by depth, and it only runs forward. Models recover time the one way they can: by writing words out and reading them back in, token by token. The factory takes that same move and makes it structural. Its defining feature is the loop: work that fails its check routes back, gets redone, gets rechecked, until it earns its way forward. So the factory isn’t more layers bolted onto the stack. It’s the recurrence the stack doesn’t have on the inside — a way of extending computation in time when a single pass, however deep, isn’t enough. That’s not merely a continuation of the mechanism, it’s a repair of its central limitation.
Second break: what flows between the stages. Between two layers of a transformer flows the full internal representation: dense, high-dimensional, almost nothing lost. Between two stations of the factory flows only what fits in an artifact: a report, a checklist, code, a document. Everything is compressed into language at every seam. That sounds like a costly downgrade, and you might wonder why we’d accept it.
Recent interpretability research suggests the cost is smaller than it looks — and the benefit is enormous. Anthropic reported in July 2026 that when their researchers located the representations a language model uses for its deliberate, multi-step reasoning, those representations turned out to be word-linked — each one tied to a word the model might say. The model’s highest-level thinking, in other words, already runs on something close to language. If the model’s deliberate reasoning is nearly linguistic anyway, then forcing the factory’s inter-station channel to be language loses little — and buys something the model’s internal channel can never offer: every seam in the process becomes something a human can open and read.
The better analogy
That same research points to what the factory actually resembles — and it isn’t the layered stack. It’s an older idea from cognitive science called the global workspace.
The theory pictures a mind as a collection of specialists: many processors working in parallel, unconsciously, and largely in isolation from one another. What makes some information “consciously accessible” is admission to a small shared channel — the workspace — which is broadcast where other specialists can see it and use it. Most of what a brain does never touches the workspace. What does touch it gains special properties: it can be reported, deliberately controlled, reasoned with.
Anthropic reports that a structure like this emerged, unbidden, inside their models during training — a small set of internal patterns doing the deliberate work, riding atop a sea of automatic processing. Nobody designed it, though it may be a solution that intelligent systems converge on because it’s a good way to organize computation.
Now re-read the factory’s design principles. Agents work in parallel, in isolated contexts, each a specialist at its station. There is no shared memory between them. They communicate through exactly one channel: artifacts left in a shared workspace, where any station downstream can read them. Everything that matters to the line must pass through that channel; nothing else passes between workers at all.
We arrived at that architecture for engineering reasons — isolation makes agents reliable, artifacts make handoffs unambiguous. But what we built is a global workspace, almost clause for clause. The factory is organized like a mind: specialist processors underneath, a narrow broadcast channel on top, and the consequential decisions forced through the channel.
The inversion
Inside a language model, the workspace is buried. It emerged on its own, encoded in patterns of neural activation, and reading it required inventing new instruments; the researchers had to build a lens just to see what their own model was thinking. The workspace is real, but it is private by default, and making it legible is a research program.
The factory is built inside-out. Its workspace isn’t hidden in activations — it’s a directory of documents. Its broadcasts need no decoding: they’re reports in plain language. Every thought that passes between its specialists is a file you can open, written for a reader, timestamped and permanent. The factory’s workspace is public by default. The visibility we build on top of it — a live view of the line showing what ran, what failed, and how many times a station retried before its work passed — is a window: it displays a workspace that was already written to be read. We could build that view easily precisely because legibility was not a feature we added, it was instead the only kind of workspace the factory could run on.
This is the architectural way of saying what we’ve argued before: the factory has no subconscious between its workers. An individual agent reasons privately inside its station, as all neural networks do. But nothing an agent thinks can affect the line unless it’s written down — and once written down, it’s part of the record. The design forces every decision of consequence through the one channel humans can read.
The pattern that keeps recurring
Step back and the same structure of organization appears at different scales. Inside a model, automatic processing everywhere, with deliberate reasoning routed through a small emergent workspace. Inside a factory, autonomous work at every station, with every consequential handoff routed through a designed workspace of artifacts. In both cases, most of the activity is cheap and parallel — and invisible. But the decisions that matter are forced through a narrow place where they become visible, checkable, and usable by others.
Minds keep discovering this architecture, and now we find ourselves building it deliberately. Not because the factory needs to resemble a mind — ours needs to modernize systems — but because the problem is the same: how to let a great deal of powerful, opaque processing happen underneath while surfacing accountability.
The difference is where the light reaches. In the large language models, the workspace emerged in the dark, and science is still building lamps to see what happened. In the factory, we put the workspace squarely in the light, and left the parts that could be checked in the dark.
Inside our dark factory, it turns out, there’s a lighted room. We built our factory, and Imogen, around it.