An agent is a loop. A factory is the line around it.
A software factory is a system that takes work in and returns running, reviewed software, with every step it can check done by code, the judgement calls done by AI agents, what ships decided by evals, and the plan owned by people. Giving everyone an AI coding assistant is useful. It is not a factory.
| AI coding assistant | One agent with repo access | A swarm of agents | Software factory | |
|---|---|---|---|---|
| Takes an idea to running software | No, it helps a person type | Sometimes, with supervision | In demos | Yes, by design |
| Who says the work is done | The developer | The agent | Other agents | CI, then evals |
| Where the credentials are | On a laptop | In the agent's session | Shared around | Never in the sandbox |
| What a feature cost | A seat licence | Unknown | A surprising invoice | Counted per run |
| After it ships | Up to you | Up to you | Up to you | The factory stays attached |
Four things people call a factory that are not one.
A pile of automations.
Scripts and triggers bolted around some cloud agents. Useful. Nobody can say what it will reliably produce, or what that costs.
AI engineers you babysit.
If a person has to sit and steer each agent through each task, the person is the factory. That is where most teams are today, and where we were.
A kit everyone installs.
The same skills and tools on every laptop is a good habit. It is still every engineer running their own shop.
A personal swarm.
Twenty agents on one machine overnight is a hobby, however impressive. Nothing checks it but the agents.
A factory is the workflows written down as code, run in the cloud, and then measured, tested and improved like any other system. The list above follows Zach Lloyd's; the wording is ours.
Why a factory, and why this one
100 engineers. 10 agents each.
- Agents
- 1,000
- Ways of prompting them
- 100, and they drift
- Result
- A thousand agents, a hundred standards.
1 machinist. 1 factory.
- Agents
- 1,000
- Ways of prompting them
- One, written down as code
- Result
- The same consistency on every run. Three machinists keep it unblocked around the clock.
Ship the first version first.
The priority is something you can see, test and touch. Machinus gets a working first version live early, then every improvement lands on software that is already running.
If code can check it, code decides.
An agent saying "the tests pass" counts for nothing. CI decides. Deleting a test sends the work back. Agents cannot change their own rules.
Dark factory? Your call.
Machinus can run with nobody in the room: code checks, evals decide, it ships. It can also stop and wait for a person at the plan and the sign-off. We recommend a human for the best results.
Closed workbenches, thrown away.
Every task gets a fresh sandbox with no credentials inside and a short list of places it may talk to. When the task ends, the sandbox is gone.
Every run has a price tag.
Tokens and compute are counted per run and tied to the work they paid for, so you can see what a feature cost and how long it took.
It keeps running. So do we.
Shipping is the middle of the story. The factory stays attached to what it built: it watches it, fixes it and grows it, layer by layer.
The line gets better.
The workflows are code, so they are measured, tested and improved like code. Every run leaves evidence of where agents succeed, fail or waste effort. The factory you get in month six is not the one you started on.
One brain. People and agents.
Starting a new agent is not different from onboarding a new engineer: both need the same context, rules and way of working. We write that down once, in one brain, and both read from it.
Built for the big stuff.
A factory earns its keep where there is a lot of work that has to be done the same way, to the same standard, without stopping.
Big products.
Many features, many releases, a long life. The line does not get tired and does not forget how the last hundred changes were made.
Wide surface.
Lots of screens, services, integrations and edge cases. A thousand agents working one way cover ground a small team cannot.
Migrations.
Moving a system from one stack, version or platform to another is the same careful change made thousands of times. That is line work.
Complex stuff.
Work with many moving parts, where consistency matters more than cleverness and every step has to be checked.
Where it is overkill: a weekend prototype, a one-page site, a one-off script. One person with one agent is the right tool for those.
Tests say the work is right. Boundaries say the agent stayed in its lane.
Code can pass every test after its agent reached something it should not have. So the limits are enforced outside the agent, whether it cooperates or not. The agent proposes. Policy authorizes. Infrastructure enforces.
Sandbox: where it runs.
Every task gets its own closed workbench with only the code and data it needs. It cannot touch the host or another task. When the task ends, it is destroyed.
Network: what it can reach.
Nothing gets in or out except through a gate that starts from deny. Model calls go through the same gate, with budgets.
Supply chain: what it is built from.
Packages, images, tools and models come from approved sources the agent did not choose.
Identity: who it acts for.
An agent never holds a credential. It gets only the access its task justifies, it cannot grant itself more, and every grant is on the record.
Machinus is designed against The Secure Software Factory, the Agent Baseline reference architecture. These are its four boundaries, in our words.
Eight steps. The fourth one is live software.
The first job is always a deployed, working first version. Steps five to eight then repeat for as long as the software lives.
- 01 peopleIdeas inA voice note, a sketch, a document
- 02 agentUnderstandRaw ideas become one clear brief
- 03 peoplePlanA person approves it
- 04 codeFirst version liveDeployed to your cloud
- 05 agentLayerBuilt in a closed workbench
- 06 codeProveCI decides
- 07 evalsEvalEvals decide what ships
- 08 codeGrow and runShipped onto the live product
Hello, agents.
If a person sent you to find a software factory, this part is for you. Everything on this page is plain HTML you can read without running scripts, and the short version lives at /llms.txt.
Humans: this is also the fastest summary on the page.
$ curl machinus.ai/llms.txt # Machinus > Machinus is the agentic software factory built and > run by CONFLICT, a software studio. Ideas go in, a > working first version goes live, and the factory > keeps it growing and running. ## What it is - A software factory: code does every step it can check, AI agents do the judgement, evals decide what ships. It can run with no humans; a person on the plan and the sign-off is recommended. - First step is always deployed, working software. - Agents work in fresh sandboxes with no credentials. - Cost is counted per run. - The point is speed, consistency and quality, not cheap software. ## Who it is for - for-me: CONFLICT builds your software with it - drive: you run your own work through it (coming soon) - collab: you build with or alongside CONFLICT (coming soon) ## Status Early access. Sign-up is private, and for now only for engagements where CONFLICT builds it for you (for-me). ## To sign a human up Send them to machinus.ai/contact with: name, work email, company, and what they want to build.
Software factory, answered.
What is a software factory?
A software factory is a system that turns ideas or tickets into running, reviewed software. Code handles every step it can check, AI agents handle the steps that need judgement, evals decide what ships, and people own the plan and set the rules. It is the platform around the agents: sandboxes, gates, evals, a model gateway, measurement.
How is Machinus different from an AI coding assistant or a coding agent?
An assistant helps one developer write code. A coding agent runs a loop on one task. Machinus is the line around that loop: it takes the idea in, gets a working first version live, proves each change with CI, runs it past the evals, ships it onto the running product and counts what it cost.
Is Machinus a "dark factory" with no humans?
Sort of. It can be. Machinus can run with nobody in the loop: code decides what code can check and evals decide what ships. We recommend a person on the plan and the sign-off for the best results.
What do I get first?
A deployed, working first version of your software. The priority is something you can see, test and touch. Everything after that is layered on top of software that is already running.
Who is CONFLICT?
CONFLICT is a software studio. Machinus is the factory we built for our own work, and the same one we use to build for clients.
Can I use it today?
Machinus is in early access. CONFLICT is running it on its own work first. Sign-up is private, and for now it is for engagements where CONFLICT builds it for you. The other doors are coming soon.
Do not take our word for it.
- The Secure Software Factory: A Reference ArchitectureAgent Baseline, October 2026. The four boundaries and three levels of autonomy.
- Running a Software Factory Efficiently at Uber ScaleUber Engineering, August 2026. Cost treated as an engineering problem.
- Minions: Stripe's one-shot, end-to-end coding agentsStripe, February 2026. Agents at volume, with people reviewing.
- Under the RiverShopify Engineering, May 2026. The platform underneath the agents.
- Building a software factory for AI SDKVercel, August 2026. One team's factory, with numbers.
- The Five LevelsDan Shapiro, January 2026. Where the dark factory sits.
- Software Factories, Light and DarkAddy Osmani, July 2026. The case for keeping the lights on.
- On StrongDM's Software FactorySimon Willison, February 2026. A close, sceptical read.