AI agents are already shipping production code. They plan features, write tests, open pull requests, deploy to staging, fix what they broke. Within a few years, most of the software the world runs on will be built this way.
Manufacturing has a name for the end state: the dark factory. Lights-out production. Machines running because no human is there to watch. Borrowed into software, it's a codebase where agents plan, code, test, and ship while nobody's looking.
Dark factories are coming. The real question is who builds them, and whether anyone should trust what comes out.
Throughput Is Not the Prize
Implementation cost has collapsed. Anyone can spin up working software now. Agents, copilots, vibe-coded one-shots, all of it. The question isn't whether software gets built anymore. It's whether what gets built is worth paying for.
The market is splitting in two.
At one extreme is personal software. People build exactly what they need, when they need it. Their own ingredients, their own air fryer, their own taste. They don't have to wait for vendors anymore.
At the other extreme is crafted software. Built by people who understand what users need better than users can put into words. It takes taste, framing, and the kind of judgment that turns working code into something people actually want to use. Think of the master-chef restaurant.
Both extremes are growing.
The middle is the TV-dinner aisle. Mass-produced, cookie-cutter SaaS, built by dark factories that scan markets for opportunities and crank it out. When anyone can generate their own slop, nobody pays for someone else's.
Throughput stopped being the prize the moment everyone got it. Craft is what's left. A dark factory can scale throughput, but not craft. Lit Factory is for the teams scaling craft — and for organizations that aren't willing to bet their reputation on slop.
“Trust the Black Box” Is Not a Strategy
Most autonomous-agent platforms hand you a black box. You give it a goal and wait. Eventually it comes back, either done or broken in some way you can't diagnose, because you never saw 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.
Underneath all three is a deeper assumption: that productive work belongs to agents, and humans belong at the edges — setting goals, approving outputs, cleaning up messes. The black box is what that assumption builds. A factory designed around it never tries to make the humans on the floor better at their craft, because it doesn't think of them as doing the craft in the first place.
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, and who treat humans and agents as a single workforce instead of a hierarchy. Dark factories produce slop. Slop is what you get when you can't see the work until it's done, and when you've quietly stopped investing in half the people doing it.
A Lit Factory Is the Inverse
A Lit Factory is the antidote. Machines still do the work, and 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 — whenever it makes sense to.
That's what we're building.
Lit Factory is where human + AI teams do their work in the open: a single floor across your tools, with a dial from full human to full autonomy.
The skeptic's first response is reasonable: software already has logs, dashboards, traces, PR reviews. The lights are already on.
They aren't. Those tools are retrospective and tool-specific. You can read what an agent did in GitHub, separately read what it did in Linear, separately watch the staging deploy. By the time you've stitched the picture together, the agent has moved on. And no other agent could see any of it in time to coordinate.
Lit means live, unified, and machine-readable. The difference between forensics and supervision.
Real factories have an andon cord: when something goes wrong, anyone on the line can pull it, and the whole floor sees the light. Lit Factory works the same way, and the cord doesn't care who pulls it. An agent stuck mid-task. A human mid-session who needs a second pair of eyes. The AI answers most in seconds, drawing on context the floor already holds. When it can't, the question is visible to anyone qualified, and the answer flows back into the session — no copy-paste through Slack. The night shift doesn't stall because one human is asleep. The day shift doesn't stall because the answer is buried two tools away.
Visibility is also what makes autonomy bigger, not smaller. Picture two teams running the same agent. Team A hands it a goal and waits. Team B watches it work, spots a wrong turn at minute twelve, redirects in two sentences, and lets it finish. Team B ships more, with more autonomy, because they can see. Teams that can watch what their agents are doing can give them bigger jobs. Teams that can't, won't.
Human in Control. Not Human in the Loop.
The industry's term for human oversight is “human in the loop.” It puts you at the end of the line. The agent does the work, you approve the output, and the loop closes. That works fine until it doesn't. At scale, the loop becomes the bottleneck, and the human becomes a rubber stamp on decisions they never saw being made.
A dark factory treats humans as a checkpoint. A Lit Factory treats them as the workforce that runs it — directing the floor, and doing the work only humans can.
In a Lit Factory, the human directs and does the work. You set the autonomy band before the Shift starts. You watch the work in flight, not after. You step in when nuance is at stake, or when an agent asks for clarification, or when you spot something the model couldn't. And when the work is yours to do, the factory briefs you the same way it briefs an agent — same context, same view of the floor — so your craft compounds with everything happening around it. The agent doesn't end the work with “approve this?” because you've already been directing it, and sometimes doing it alongside.
That only works if the factory is doing real work for you, not just routing work through you. It holds the context, so you don't arrive at a task cold. It holds the controls, so the rules of engagement are set once and respected by every agent on the floor. It holds the handoffs, so work can be put down at the end of a day and picked up the next morning — by you or by an agent — without losing the thread. And it holds the memory, so what you've learned, decided, and ruled out doesn't have to live in your head. You stop carrying the system. The system starts carrying you.
That's not theoretical. When you're mid-session and need a second pair of eyes, you don't leave your flow to assemble context in Slack — you pull the same cord your agents do, and the floor routes the question to whoever can answer. The factory carries the context for you, both directions.
That's the line that separates supervising slop from directing craft.
Read more on Human in Control →The Dial, One Shift at a Time
Autonomy isn't a switch. It's a dial.
The dial moves one Shift at a time. A Shift is the smallest unit of agent work in Lit Factory. It has a roster of agents, a work list, an autonomy band (“full autonomy on these, ask on these, never touch those”), and standing orders. It lasts an evening, or a week. Many Shifts run at the same time across the floor, one per person or team. Autonomy is a per-person trust, not an org-wide policy.
Day shift, night shift. You drive yours; your agents run the other. Elsewhere on the floor, someone else's shifts are going the other way. The floor stays lit through all of them, and you walk in the next morning to a recap of what your agents got done.
The dial ratchets up over time. The first night shift might be “run the test suite and report.” Three months later it's “pick three Linear tickets you're confident on and ship them, ask if you're not sure.” As trust grows, the dial moves up with it, and the floor stays lit the whole way. Trust isn't a vibe; it's a number — what your agents actually did without asking, against the band you set, is the input to next week's dial.
The dial is also reversible. At any moment, on any task, a human can step in or step out. The agent picks up where the human left off, and the human picks up where the agent left off. The handoff is clean in both directions.
This is why the dial never aims at darkness. Humans hold the forward edge: the taste that calls something wrong even when it's technically right, the judgment that knows what to ship and what to kill, the read on a problem before anyone has framed it. Models work from what's already been said and written. Humans work from what's coming next. The dial scales automation without losing the people who do that work.
There's a governance answer hiding here. The autonomy band is the policy — configured per shift, earned per team, narrow for new contributors and wide for trusted ones. Risk tolerance becomes a knob, not a wiki page.
What This Changes
For teams
Autonomy stops being a bet. The handoff is something you can see, so you scale craft, not slop output.
For humans
You stop carrying the system in your head. The factory holds the context, the handoffs, and the memory; you hold the craft. The work you keep is sharper for it — not just whatever was left over.
For AI
Equal context, equal capability. An agent that can see what other agents see can actually collaborate with them, not just run 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, one shift at a time.
Two Bets
There are two bets you can make about what AI does to software.
One: optimize for raw throughput. Run the factory dark, generate at the floor, and capture the commodity end of the curve while it lasts.
The other: build at the ceiling. Use the same leverage to make software that's actually worth paying for. Humans and AI, both in the open, both at full strength, with the taste and framing that turn working code into something people actually want to use.
We're making the second bet — and we already live it. Pacific-time humans hand off to agents every evening; the recap is waiting in the morning. Lit Factory is for the teams making the bet with us.
AI is the biggest expansion of
human cognition.
Lit Factory is how you use it
without losing yourself.