Your Agents Need a Software Factory

Your agents need a software factory — a production system around them with standardized inputs, quality gates, and evidence-backed output. A coding agent is a worker; the factory is what turns its work into deployed, verified software. The agent gets the credit in the demo; the factory ships the product. In Vibe Coding Is Dead: The Rise of Agentic Engineering, we saw how the work moved from writing code to specifying it. Here is what happens when the specification becomes input to a system.

A 1968 idea, a 2026 workforce

A coding agent is a worker. A software factory is the production system around it: standardized inputs, a defined path, quality gates, evidence-backed output. The agent gets the credit in the demo; the factory ships the software.

The metaphor predates AI by decades. Robert Bemer proposed disciplined software production on integrated tooling in 1968 (Computer History Museum). Microsoft productized the idea in a 2004 book, Software Factories, by Jack Greenfield and Keith Short (Wiley). BMW runs a platform for more than twelve thousand developers (AWS case study). The 2026 revival changes the worker, not the idea.

Signals in, verified software out

A factory turns one kind of input into another. Here the input is a bug report, a spec, or a customer complaint, and the output is deployed, verified software.

The parts that matter sit around the agents, not inside them. Standardized inputs keep specs and tickets in one format. Quality gates run tests, score risk, and route dangerous changes to a person. Evidence trails record what each agent did and why. A worker is replaceable; the line is the asset.

The early numbers

The early wins reward reading, because none of them came from a better model. Spotify merged more than 1,500 agent-generated pull requests and cut studied migration times by 60 to 90 percent (Spotify Engineering). Stripe runs scoped agents that merge around 1,300 AI-authored pull requests a week through the same human review as any other change (Bain & Company). OpenAI built an internal beta of about a million lines with three engineers steering agents (OpenAI). Amazon routes up to 70 percent of code reviews through AI (Bain & Company).

Each of those systems made the same three things precise: specs written down, acceptance criteria explicit, verification automated.

The bottleneck moved

Generation was never the hard part, and the numbers now show where the pressure went. Bain’s Technology Report 2026, based on a survey of 293 senior technology leaders, found developers complete about 21 percent more tasks, manage 47 percent more concurrent workstreams, and spend 91 percent more time reviewing output (Bain & Company).

An agent generates work faster than the surrounding process absorbs it. Teams that speed up generation without redesigning review redistribute the pain. The fix is systematic verification: automated quality gates, risk scoring that routes dangerous changes to a person, and audit trails that trace every agent action. Leverage lives in the specification, where it always was.

The sprawl behind the factory

There is a second force the factory has to absorb. Each lab ships its own agent. Claude Code, Codex, Cursor, and a list that keeps growing. Each one extends through its own skills, plugins, and configuration files. Each integration speaks its own protocol, MCP for one class of tools, A2A for another, custom APIs for the rest. Each provider keeps its own dashboard, its own task model, its own logs.

A team runs three or four of these systems at once. The task you started in one tool stays invisible to the next. The skill you wrote for one agent needs a rewrite for another. Someone, often the strongest engineer on the team, moves context between tools instead of building.

Cloud agents changed the shape of the day before anyone priced the coordination. Teams go home and the queue keeps moving. Tests get written, dependencies get upgraded, review comments get addressed. Your context for explaining that work stays scattered across five dashboards.

Analysts expect the average large enterprise to run north of 150,000 agents within a few years, up from a handful in 2025 (Gartner via Tech.co). Each agent carries credentials, permissions, and reach into production systems. The open problem is authority: who grants, tracks, and revokes what each agent can reach. Tools built to remove work created a new category of it: coordinating.

The software factory, not the noise

Kordyline started from that friction. When every agent brings its own dashboard, protocol, and log format, the strongest engineer on the team becomes the integration layer by default — moving context between tools instead of building.

We are building the alternative. We are creating the software factory, so that you can focus on products and ship new features fast: one place for the specification, quality gates that verify without a human staring at every diff, and evidence you can read when something goes wrong. The factory should be quiet enough that the specification, the review, and the product stay visible.

We will keep writing about the shift as we build. Part 1 of the series: Vibe Coding Is Dead: The Rise of Agentic Engineering.