Levr
All articles

How to Build an AI Software Factory: Every Component You Need

The layers of an AI software factory, with examples: agents and models, orchestration, repo, CI, deployment, tracker and control plane, and how to start today.

November 21, 202615 min read

An AI software factory is a delivery line for software, built in layers. Models and coding agents do the work, orchestrators run many agents at once, and the repository holds the code and the context agents read. Continuous integration (CI) tests every change, and a deployment path ships it. Above them, a tracker and a control plane hold every agent's work to the plan. Most teams already run the lower layers. The layer most of them are missing is the control plane: an independent gatekeeper, separate from whichever agents do the work, that decides when work is done on evidence rather than on an agent's word. Levr is both the tracker and the control plane, and it's free to start.

Coding agents can now finish whole tasks on their own, many at once, so writing the code isn't the hard part anymore. The hard part is coordinating all that work and verifying it. Teams such as StrongDM are building AI software factories to do exactly that. So what is an AI software factory, how do you build one, and where do you start?

Why are so many teams suddenly looking to build an AI software factory?

Coding agents changed what they do. They went from suggesting the next line to finishing whole tasks on their own. GitHub Copilot's coding agent researches a repository, plans the changes and implements them in the background, then opens a pull request. Cursor lets you run as many cloud agents in parallel as you want. Each Codex cloud task gets its own workspace and keeps working while your computer is asleep.

So the bottleneck moved. When agents write the code, the work piles up everywhere around it: planning, coordination, review, verification and deployment. One fast developer doesn't make a fast team, so leaders want the whole delivery line to run at agent speed.

That's the vision of the autonomous software factory: a line from intent to fully tested and deployed software, automated end to end, with goals set by people and human judgment at defined points, only where it's needed.

The shift is already under way. Stack Overflow ran its 2026 Developer Survey with more than 30,000 respondents and published the results in October 2026: 73% of developers who use AI coding assistants or agents use them daily. JetBrains asked more than 15,000 professional developers for its Developer Ecosystem Survey 2026, between May and July 2026, and found that 90% use AI coding agents at least once a week and 68% use them daily.

Vendors and consultancies now frame the software factory as the step after coding agents. Factory, the company behind the Droids coding agents, published Factory 2.0: From coding agents to software factories in June 2026, which says "The incremental units of this system are AI agents." BCG Platinion, the technology arm of Boston Consulting Group, wrote in March 2026 that in early 2026, pioneering organizations showed that as few as three engineers can run a software factory.

What does agentic development look like without a factory?

On many teams, each person prompts their own coding agent, in their own chat. One developer works in Claude Code, another in Codex, a third in Cursor, and the agents don't coordinate with each other.

The tasks sit in a tracker like Jira or Linear, and the agents can update them: both Atlassian and Linear offer MCP (Model Context Protocol) servers that connect AI agents to their trackers. The tracker records what each agent says, but it doesn't verify the agent's work or keep proof of its checks. So every step an agent reports, from started to tests pass, rests on the agent's own word. That's a kid grading their own homework.

Trust follows evidence: in the same Stack Overflow survey, 48% of developers said they trust AI when they can easily validate the answers. Without that evidence, the output piles up at review. Faros AI, an engineering analytics company, compared low and high AI adoption in its second-quarter 2026 report, The Acceleration Whiplash, and found about three times the incidents per pull request at high adoption.

For how this changes the way teams plan and verify work, see What is agentic software development?

The fix: a production line, not more agents. One path from plan to deployed software, with one definition of done that every agent's work must pass, whichever agent did it.

What is an AI software factory?

An AI software factory is a delivery system where coding agents take work from a plan to deployed software, while people set the goals.

The easiest way to picture it is a manufacturing plant. People set the specs and tolerances, robots do the labor, gauges inspect the work at each station, and a control system runs the production line. An AI software factory maps onto that plant:

  • People set the plans, the requirements and the acceptance criteria.
  • Coding agents are the robots doing the labor.
  • Gates and tests are the gauges at each station.
  • The control plane is the line's control system, an independent gatekeeper above the agents.

The vision is a line automated end to end, with human judgment at defined points, only where it's needed: intent and requirements, what counts as finished, and decisions and exceptions. Most teams start with bounded features and widen the scope as their checks earn trust.

For the full background, read AI software factories: how autonomous coding works and How to build a context-centric software factory.

What components does an AI software factory need?

Build that plant in software and you get a stack. This is one way to picture it, not a standard:

  • Models: the large language models doing the reasoning.
  • Coding harnesses: the agents that run those models on your code.
  • Orchestrators: what runs many agents at once.
  • Repo and project context: where the code lives and what agents read first.
  • CI and testing: what checks every change.
  • Deployment: how merged code ships.
  • Tracker and control plane: where the work is planned, and what holds every agent's work to that plan.
A layered stack, bottom to top: Models (Claude, GPT, Gemini, Grok), Coding harnesses (Claude Code, Codex, Cursor, Copilot), Orchestrators (T3 Code, Orca, Kepler), Repo + context (GitHub, AGENTS.md), CI (GitHub Actions), Deployment (Vercel), and empty Tracker and Control plane slots marked with question marks.

The coding agents compete with each other to do the work. Trackers like Jira, Linear or Levr list the work. Levr is also the control plane, holding the agents' work to the plan whichever agent does it. You bring the agents you already use.

Models and coding harnesses

The harness is the agent you work with, and the model is its brain.

All four connect to MCP servers (Claude Code, Codex, Cursor, Copilot). MCP is an open-source standard for connecting AI applications to external systems, so one factory can mix harnesses.

Orchestrators: running many agents at once

One agent is a developer with help. A factory runs many agents at once, and that takes an orchestrator.

Harnesses can orchestrate too: Claude Code subagents each run in their own context window, under a lead agent.

An orchestrator decides who runs what, right now. In plant terms, it dispatches the robots, but it doesn't set the tolerances. Holding the work to the plan is a different job, covered in What is an agent control plane?

The repo and project context

A Git host such as GitHub holds the code, the branches and the pull requests. Next to the code sit the agents' work instructions. AGENTS.md is "a simple, open format for guiding coding agents", a README written for agents. Harnesses also read their own files, such as CLAUDE.md or Cursor rules: build commands, conventions and the parts of the codebase not to touch.

Protect the main branch so every change lands through a pull request.

CI and testing

CI is the inspection station most teams already have. A CI system such as GitHub Actions builds and tests every change. On a protected branch, all required status checks must pass before a change can merge.

Tie unit, integration and end-to-end tests back to the acceptance criteria they prove, so a green build means something.

Deployment

Deployment is the shipping dock. Vercel creates a preview deployment by default when you push to a non-production branch or open a pull request. Then put a release gate in front of production: GitHub environments can require named reviewers to approve a job before it deploys.

What's still missing when every part is wired up?

You now have models, harnesses, orchestrators, a repo, CI and deployment. In plant terms, you have robots and gauges, but no control system, no tolerances and no inspection records.

  • Who works on what: agents in parallel lanes can collide, wait on each other or build the same thing twice.
  • What counts as done: CI says the tests that ran passed. It doesn't say the right tests ran. A coding agent tends to take the shortest path to something that looks done: it stubs the hard function or narrows a test until it passes. Context files such as AGENTS.md, CLAUDE.md and Cursor rules guide the agent, but they don't enforce anything.
  • The record: nothing proves what was checked, and an agent's decisions vanish with its chat.

The fix: one place for the plan and its tasks, checks written before the code, and a record of every check and decision.

The tracker and the control plane

That missing top layer is the line's control system, and it's where Levr fits. Levr is both the tracker and the control plane: the one place you and your agents work from.

Levr works with the tools your team already uses. It holds your plans and deliverables, syncs with Jira both ways and links GitHub branches, commits and pull requests to their issues. You bring Claude Code, Codex, Cursor or any MCP client, and you keep your repo, CI and deployment. Agents read and write the same issues you see, and everything an agent creates carries its identity.

Think of Levr as air traffic control for the factory. Issues record what blocks what with blocks and blocked_by links, an agent claims a task by assigning itself and moving it to In Progress before it starts, and duplicates get linked to the original.

Levr also keeps a decision ledger. Every issue lists what agents decided, sorted by how hard each decision is to undo, and a person confirms or overrides each one in one click. Approvals wait for a person, and a rule an agent proposes stays inactive until a person turns it on. People step in for the decisions that need them.

How do you hold coding agents to the plan?

A plant sets its tolerances before the run. Levr uses gates the same way: checks and tests attached to a Deliverable and written before the code, next to its acceptance criteria.

Levr checks six ways:

  • Presence: the required thing is there.
  • Pattern: the code contains, or avoids, the expected text.
  • Structure: the code is wired up the way it should be.
  • Execution: the code builds, typechecks and passes its tests.
  • Semantic: the code does what was intended, judged by AI plus hands-on checks.
  • State: the system of record has reached the required condition.

For checks no command can run, there are guided gates: a person or an agent does the check and reports what they saw, and a bare pass with nothing observed is refused.

Levr's gate kinds: Presence (the required thing is there), Pattern (the code contains or avoids the expected text), Structure (wired up the way it should be), Execution (builds, typechecks, passes its tests), Semantic (does what was intended: AI judges plus hands-on checks), State (the system of record reached the required condition), and Guided (a person or agent checks and reports what they saw).

The agent runs the gates, and Levr reads the command, the exit code and the output, so the verdict comes from evidence, not the agent's say-so. If zero tests ran, the gate fails. A task with a failing required gate can't be closed until the gate passes or someone waives it with a reason, and the failed attempt stays in the history.

The same gates run in CI: levr gates run exits 0 only when every gate passes, so a CI step can gate on it. Security gates such as secret scans, SAST (static application security testing) and dependency audits run real tools from your repository once you bind and enable them, and then they can be required too.

Gates answer verification, not validation. A gate proves the checks you specified passed. It can't prove the plan was the right one: that's still your call.

Two cards: Verified, the checks you specified passed (the gate proves it), and Validated, the plan was the right one (your call).

What our own factory shows

We build Levr with agents, on Levr. These numbers come from the Levr team's own workspace, Jul–Nov 2026:

  • 53% of agent-finished tasks failed at least one required gate the first time it was checked (181 of 341).
  • On 171 of the 192 tasks the gates caught, no test, build or typecheck gate went red: checks on the plan caught them.
  • 34% of tasks with a plan-conformance gate didn't do what the plan asked on first check (81 of 238), and 12% of tasks with a no-stubs gate left a stub or TODO behind (28 of 230).
  • 2 of 3 red gates were fixed on the agent's next try.
  • Every Done carries its proof: all 341 completed gated tasks have a recorded verdict.
  • A median of 20 checks per task, written before the code.
  • 2.4% of gates were waived (490 of 20,670), each with a written reason.

Every Done in Levr is checked against the plan. In Jira and Linear, none are.

How do you prove a gate verification happened?

A physical factory keeps inspection records, measurements, photos and video. Levr keeps that record for every gate. Every gate attempt records who ran it (a person, an agent or CI), when it ran, the exact command, its exit code and the tail of its output. A check reported without its raw output is recorded as an error, never as a pass.

Gate attempts are never edited or deleted. A rerun adds a new attempt, and a waiver is appended, so a failure stays on the record.

A gate attempt record in Levr, shown as an illustration: a required gate marked Fail, with Who (agent, person or CI), When, Command (npm test -- template), Exit code 1 and Output tail '0 tests ran'.

Every gate files proof receipts: the output of whatever tool the gate used to verify, such as logs, CLI output, CSVs and PDF reports. Levr Browser, the extension that lets your agent work in your own browser, adds screenshot and video proof receipts. All of them are filed in Levr with the work they prove.

Where Levr fits in an AI software factory

You bring the agents and keep your repo, CI and deployment. Levr does the three jobs on top: coordination, enforcement and evidence.

  • Models: What it does: The reasoning behind each agent; Factory analogy: The robots' controllers; Examples: Claude, GPT, Gemini, Grok; Levr's role: You pick
  • Coding harnesses: What it does: Run models on your code; Factory analogy: The robots; Examples: Claude Code, Codex, Cursor, GitHub Copilot; Levr's role: You pick; Levr works with any MCP client
  • Orchestration: What it does: Runs many agents at once; Factory analogy: Dispatching robots to stations; Examples: T3 Code, Orca, Kepler; Levr's role: Holds their work to the plan
  • Repo and context: What it does: Holds code and agent instructions; Factory analogy: Work instructions at each station; Examples: GitHub, AGENTS.md, CLAUDE.md; Levr's role: Links branches, commits and PRs to issues
  • CI and testing: What it does: Builds and tests every change; Factory analogy: An inspection station; Examples: GitHub Actions with required checks; Levr's role: Levr gates run in CI
  • Deployment: What it does: Ships merged code safely; Factory analogy: The shipping dock; Examples: Preview deployments, release approval; Levr's role: You keep yours
  • Tracker: What it does: Lists and plans the work; Factory analogy: Production orders; Examples: Jira, Linear, Levr; Levr's role: Levr, with two-way Jira sync
  • Control plane: What it does: Holds every agent's work to the plan, with proof; Factory analogy: The line's control system, gauges and inspection records; Examples: Levr; Levr's role: Plans, issues, tests and gates across every agent, with a record of every gate attempt

How do you build an AI software factory?

You can start yours this afternoon:

  1. Sign up for Levr for free. Create your account.
  2. Connect the agent you already use. Run npx @levr-one/cli@latest mcp add; it finds the AI clients on your machine and adds Levr to each, and the first connection opens your browser to sign in once.
  3. Prompt a plan for a simple, bounded feature, with Deliverables and their acceptance criteria. These are your tolerances.
  4. Ask your agent to deploy the gates: "Deploy the gates for this plan onto its deliverables."
  5. Ask your agent to work the plan, and watch. The agent claims a task and works on a branch. Your deliverables move through green gates, and a red gate keeps its task open until it's fixed.
  6. Add the gates to CI with levr gates run. The pull request passes review and the verification gates in CI, and the feature deploys.

You've got your first production line running, end to end, from plan to deploy. Then widen the scope as the gates earn trust.

The finished line, running end to end: Plans, Coding agents with an Orchestrator, Repo, Gates with Proof, CI and Deploy, under a top bar labelled Tracker + control plane with the Levr logo.

Start your software factory today

Try Levr free, and start your software factory this afternoon. Better agents help. A better factory helps more. Levr makes done mean proven.

For a deeper look at software factories and control planes, read AI software factories: how autonomous coding works and What is an agent control plane?