AI agents are starting to do more of the building, testing, deploying, and maintaining than any single person on a team. Soon, whole roadmaps will run on agents. Humans will jump in when something needs them, not the other way around.
The industry has a name for where this is going: the dark factory. The phrase comes from manufacturing. It's the lights-out production line, where machines run because no human is there to watch. Borrowed into software, it describes a codebase where agents plan, code, test, and ship without anyone watching.
Dark factories are coming. So the question is who builds them, and whether anyone should trust the result.
“Trust the Black Box” Is Not a Strategy
Most autonomous-agent platforms ask you to trust an opaque process. You hand off a goal. You wait. The agent comes back when it's done. Or when it's failed in some way that's hard to diagnose, because you couldn't see what happened in between.
That works until it doesn't. When it breaks, it breaks in three ways.
You can't intervene. When an agent goes off track, you find out from the result, not from the work itself. By then the damage is already downstream.
Composition breaks. When multiple agents work in parallel, none of them can see what the others are doing. You get overlapping work, silent contention, missed handoffs.
Nothing teaches. A black box doesn't tell you why it worked or why it didn't. The next run is as opaque as the last.
The teams that win the autonomy era won't have the most autonomous agents. They'll be the ones who can run autonomy at scale without losing the thread.
A Lit Factory Is the Inverse
In manufacturing, the opposite of a lights-out factory has a name: a lights-on factory, or in shorthand, a Lit Factory. Machines still do the work. Humans aren't always present. But the floor is lit, every operation is visible, and the work can be inspected, joined, paused, or resumed by anyone, human or machine, at any time.
That's what we're building.
A Lit Factory is the orchestration substrate where every agent's work, context, and decisions stay in plain sight, to humans and to other agents, from human-in-the-loop all the way to fully autonomous.
A Lit Factory isn't less autonomous than a dark one. It's more, because the more you can see, the more you can hand off. Teams that can watch what their agents do can give them bigger jobs. Teams that can't, won't.
Real Agency Requires Real Substrate
You can't hand an agent true agency by declaring it autonomous. Agency is something a system grants, not something an agent claims. And the system has to earn the right to grant it.
Four properties have to hold at once.
Observable. Every action and decision traceable in real time, not just in a log you read after something went wrong.
Trustable. The data the agent draws on can't be stale or wrong. If the agent acts on a fiction, it doesn't matter how good the model is.
Interconnected. An agent that only sees its slice of the work, while the rest of the work moves around it, isn't autonomous. It's lucky.
Always up to date. What was true five minutes ago has to still be true now, or the agent is making decisions in the past.
Build a system where all four hold, and you can hand off real work with confidence. Skip any of them, and what you call autonomy is closer to recklessness. An agent making decisions on a stale, fragmented, unobservable substrate isn't autonomous. It's just out of your sight.
A Lit Factory is the substrate where the four hold by construction. That's why agents inside it can be trusted with bigger jobs than agents anywhere else.
Humans Get Elevated, Not Replaced
The dark factory framing assumes the goal is to take humans out of the loop. We don't believe that.
Humans don't get replaced in a Lit Factory. They get elevated. The busywork of running the factory gets handed to agents. Status updates. Manual coordination. Ticket triage. All the things that filled the day but never required taste.
What's left is what only humans can do. Understand what people actually need. See the nuance in a request. Make the call when the rules don't quite fit. Choose what's worth building in the first place.
Machines serve humans, not the other way around. A Lit Factory is built on that order.
The visibility, the unified context, the reversible handoffs — all of it exists so the human at the center can stay in command without getting buried in the mechanics. Only humans understand human needs at the level where it actually matters. Any system that forgets that is building toward the wrong destination, no matter how autonomous it gets.
What Makes a Factory Lit
Five things separate a Lit Factory from a dark one.
Unified context
Every agent and every person draws from the same living model of the work: projects, decisions, conversations, deliverables. No agent holds private context the rest can't reach.
Observable agency
Every action an agent takes gets recorded with its intent, input, and outcome. This isn't a log you grep through after the fact. It's a live feed that another agent or person can join, interrupt, or branch from.
Multi-actor coordination
Agents see each other's work, not only their own. Devin running here, Claude Code reviewing there, a Copilot blocked on an API key over there. The factory floor coordinates itself, and humans watch the whole orchestration on one surface.
Reversible autonomy
At any point, on any task, a human can step in or step out. The handoff is clean in both directions. The agent picks up where the human left off, and so does the human.
Continuous improvement
When work is visible, it produces signal. Signal becomes learning. Patterns surface, workflows compress, and the factory gets smarter with every shift.
What Changes in a Lit Factory
For teams
Autonomy stops being scary. You ship more by handing off more, because handing off doesn't mean losing sight anymore.
For humans
The busywork goes to the factory. The judgment calls stay with you.
For AI
When the context is equal, the capability is equal. An agent that can see what other agents see can actually collaborate with them, instead of just running in the same room.
For organizations
Every agent hour becomes something you can inspect, replicate, and improve on. You don't buy autonomy. You build it.
The Choice in Front of Every Team
The dark factory isn't a future we walk into by accident. It's a choice. A choice to optimize for raw agent throughput at the cost of everything else a team actually needs.
A Lit Factory is the other choice. Same throughput. Full visibility. Humans in command. Real composability.
We're building Lit Factory for the teams that pick the second one.
The future of software work is autonomous.
Whether it stays visible, and whether it stays human, is a choice.
Make it both. Come build it with us.