How we build

What is a software factory?

Machinus is how CONFLICT builds software: faster, the same way every time, and to a standard that holds. Here is the definition, what a factory is not, eight arguments for one, where it fits, the limits agents work inside, the eight steps, and the questions people ask.

What is a software factory

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 assistantOne agent with repo accessA swarm of agentsSoftware factory
Takes an idea to running softwareNo, it helps a person typeSometimes, with supervisionIn demosYes, by design
Who says the work is doneThe developerThe agentOther agentsCI, then evals
Where the credentials areOn a laptopIn the agent's sessionShared aroundNever in the sandbox
What a feature costA seat licenceUnknownA surprising invoiceCounted per run
After it shipsUp to youUp to youUp to youThe factory stays attached
What it is not

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.

Eight arguments

Why a factory, and why this one

Speed. Consistency. Quality.That is what a factory is for. It is not cheap, and it is not meant to be: thousands of anything never is. The same line, run the same way every time, gets a working version in front of you fast and keeps the standard from slipping.
Without a factory

100 engineers. 10 agents each.

Agents
1,000
Ways of prompting them
100, and they drift
Result
A thousand agents, a hundred standards.
With one

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.

Where it fits

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.

What agents may do

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.

How it runs

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.

  1. 01 peopleIdeas inA voice note, a sketch, a document
  2. 02 agentUnderstandRaw ideas become one clear brief
  3. 03 peoplePlanA person approves it
  4. 04 codeFirst version liveDeployed to your cloud
  5. 05 agentLayerBuilt in a closed workbench
  6. 06 codeProveCI decides
  7. 07 evalsEvalEvals decide what ships
  8. 08 codeGrow and runShipped onto the live product
code decidespeople decideevals decideagent judgement
For AI agents

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.
Questions

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.

Further reading

Do not take our word for it.

Want the line on your problem?