Feature-branch activity climbed 59% year on year while main-branch activity fell 7%, according to refactoring.fm's analysis of CircleCI's 2026 delivery data. More drafts, fewer releases. That divergence is why the software factory has moved from metaphor to architecture: producing a change became cheap, and trusting one did not.
Where the queue forms
Most teams already have agents in several places at once. The distinction that matters is the one Overcut's guide draws: an agent is a worker, and the factory is the production system around it, with intake, stations, quality control and evidence. Buying another agent licence does not shorten the path a change travels.
Augment Code reports that the gain leaders see at organisational level falls a long way short of what individual adoption promises, because review queues, planning cycles and deployment stay exactly as they were. hackers&wizards names the resulting state the velocity trap: agents write code inside strict checks, and pull requests stack up in front of the same reviewers. More output, same delivery.
Measure the path before you touch it. Take twenty changes of different sizes and timestamp the signal, the first commit, the first green pipeline, the merge and the production release. The station with the longest wait gets the next investment. In refactoring.fm's coaching work that station turned out to be manual QA for some teams, requirements for others, review for many, and customer feedback for one, but it was never coding.
The handoff is a contract, so version it
Between people, a handoff survives on shared context and a message thread. Between agents, it has to be an artefact that states what is passed, in what shape, with what proof, and what happens when the receiving station cannot accept it. re:cinq's software factory guide makes the point that a specification earns its place only when validation can compare against it, and that a request to create a tenant onboarding API leaves every consequential choice open.
# factory/stations/review.contract.yaml
station: review
consumes:
spec: specs/SPEC-412.md # versioned, acceptance criteria included
change: refs/heads/agent/SPEC-412
base: main@sha
produces:
verdict: pass | fail | escalate
evidence:
- check: unit
run: ci/99812
- check: contract-tests
run: ci/99813
- check: perf-budget
result: p95 214ms against a 250ms budget
findings: review/FINDINGS-412.json # each finding cites a rule id
limits:
attempts: 3
wall_clock: 25m
spend: 120000 tokens
on_exhaustion: escalate-to-owner
Four fields do most of the work. Acceptance criteria give the coding agent a target it can finish. Evidence gives the review and release stations something to check without inheriting the author's assumptions. Limits stop the loop where two agents trade the same fix; when the attempt budget is spent, the work goes to a named owner. A rollback note is written before the change exists, which is the cheapest moment to find out that nobody knows how to undo it.
Gates placed by blast radius
Line-by-line review of every agent pull request is a craft-era habit, and at ten times the volume it becomes ceremony. Put the human where a mistake is expensive and the call needs judgement, and let the line hold the rest. Overcut's advice is to grant autonomy by class of work, since a documentation fix and an authorisation change carry very different blast radii.
| Class of change | Worst realistic outcome | What the line can prove | Who signs |
|---|---|---|---|
| Dependency bump, lint, docs, test backfill | A red build or a stale page | Build, unit suite, licence and vulnerability scan on the real dependency graph | Nobody; merge on green |
| Schema migration | Data loss, or a lock on a hot table | Dry run against a production-shaped copy, lock analysis, forward and reverse migration both executed | Platform owner, on evidence |
| Authorisation and tenancy | Cross-tenant read, privilege escalation | Contract tests for every role, denial cases, policy-as-code result | Security reviewer |
| Public API shape | A consumer you do not control breaks | Consumer contract tests, deprecation window check | API owner |
| Interface copy and layout | Wrong words in front of a customer | Screenshot diff, accessibility scan | Product, after release behind a flag |
| New service boundary | A boundary nobody can operate or unwind | Very little | Human design gate before any agent starts |
Treat the table as a starting position. Revisit it every time a defect escapes, because an escaped defect is a statement about the line. The New Stack puts it in one line: "Every escaped defect is a process bug." That sentence should change where a gate sits. Blame has no place in the change record.
Guardrails that hold at the boundary
An instruction in a prompt is a request. A permission boundary is a fact. Assume an agent will do anything the line allows, then design the line so that everything it allows is safe. TrueFoundry's account of the agentic factory puts the load-bearing layer beneath the agents, in credential custody, policy mediation, telemetry and spend metering, and asks the question that decides whether any of it holds: which calls pass through the gateway and which route around it. Everything that bypasses mediation needs its own control.
nhimg.org's guidance on securing the delivery path is blunt about the identity model. If one identity can change code, run builds, approve a release and deploy to production, the pipeline is too permissive. Split build, signing, promotion and deployment so that a stolen credential buys one station and nothing further.
# factory/station-policy.yaml, reviewed like application code
stations:
coding:
identity: oidc://stations/coding
can_write: [refs/heads/agent/*]
denied: [deployments/*, secrets/*]
release:
identity: oidc://stations/release
can_write: [deployments/staging, deployments/production]
requires: [unit, contract-tests, policy, provenance]
bypass_actors: [] # no admins, no bots, no temporary exceptions
on_check_error: block
Fail closed. A check that cannot run is a failed check. The line blocks. A review verdict does not widen what the release station may do, so trust never travels down the chain.
Evidence from a real environment for every change
A mock describes a world that does not exist, and it was affordable only while changes were slow and rare. re:cinq reports analysis of patches that passed a standard benchmark's tests where 29.6% behaved differently from the accepted fix. Green on a stub proves the stub.
So give each change its own test station: the changed service plus the services, databases and APIs it meets after release, created in seconds, torn down on merge, deploying only what the change touched and sharing the rest. Route test traffic by header, or shadow a copy of live traffic at that edge. The reviewing agent then receives a run id and a diff with the evidence attached.
Fresh context is part of the design. A reviewer that did not write the change, working from the specification and an adversarial brief with no write access to the acceptance evidence, catches what the author cannot see about itself. Keep the deterministic gates, and keep them narrow: static analysis blocks injection classes and stays structurally blind to authorisation logic, which is why the tenancy contract tests in the table above carry more weight than the scanner report.
Instrument the line, then grant autonomy
Five signals tell you whether the factory works: lead time from signal to production, change failure rate, rework rate on agent-authored changes, cost per merged change, and the share of agent pull requests that merge without a human edit. Overcut's guide nominates that last pair as the honest pair, because pull request volume measures activity and rewards the wrong behaviour the moment it becomes a target.
Grant autonomy one class of work at a time, and only when the evidence says the gates hold. Start with the classes where a mistake is cheap to detect: dependency bumps, test backfill, lint. Move to schema and authorisation work once the contract tests have caught real regressions without help. refactoring.fm's reading of the CircleCI report is that AI amplifies whatever delivery system already exists, so a team with flaky tests and a slow pipeline gets more of both. Nothing in the model rescues a weak foundation; it multiplies it.
Keep a bench. The first version of something new, a strange production bug and a design nobody has tried stay in an engineer's hands until they are understood well enough to standardise. That is where judgement lives, and it is where the next generation of contracts comes from. An engineer who has shipped, rolled back and debugged a service by hand writes better station boundaries than one who has only read about them.
The model is not the differentiator. Every team can rent the same frontier agent. What separates them is the line around it: contracts between stations, gates placed by blast radius, verification on every change, and an owner who reads the escaped defects and moves a gate.
Sources
- Software Factory: What Changes When AI Agents Run Delivery | Overcut
- The Era of the Software Factory
- What Is a Software Factory? AI Delivery Explained | re:cinq
- The Engineering Leader's Guide to Building a Software Factory | Augment Code
- Software Factory | hackers&wizards
- The Agentic Software Factory, Explained | TrueFoundry
- Why does secure software development need to include the software delivery pipeline as well as the code itself? | nhimg.org
Every escaped defect is a process bug.
Source: In the software factory, engineers become process engineers, The New Stack


