Agents rebuild your system with everything you know today, and rebuild it again as you learn more tomorrow. Each new build runs in shadow on your real traffic, touching nothing, until it proves it is better. Then it takes over, and the next one starts.
Early build, on Cloudflare. By System3 Inference.
Each cycle starts with what the last one learned.
Why rebuild, written before any code: what changed, what limit the champion hit, and the measure the challenger must beat.
What the system must do and why. Each requirement has an owner and an expiry. Each decision keeps the options it rejected. Agents read it over MCP.
Agents write the challenger: a fresh build of the whole system from the ledger, not a patch on the old code.
The challenger gets the same live traffic as the champion and cannot act on it. A model judge rules on each difference. A person rules on the critical ones.
The challenger takes production only when it matches on what matters and wins on the charter's measure. Then the next cycle starts.
The champion keeps shipping fixes the whole time. Each fix goes into the ledger, so the next challenger learns it as knowledge, not as a patch.
The proving ground is what makes it safe to let agents rebuild a system people depend on.
Tests check what someone thought to check. The proving ground checks what your users actually do, including the long tail where rebuilds break.
The challenger cannot send, charge or call out. Its side effects are recorded and compared instead. The boundary is checked every time a challenger starts.
A new data model is not a false alarm. Outputs, state and intended side effects are compared by what they mean, within tolerances you set.
The judge clears the bulk. Your team decides the cases that touch money, safety or trust, and those rulings train the judge.
When models, hardware, data or requirements change, the next cycle rebuilds for the change. Each cycle starts with a fuller ledger and a better judge, so each one costs less.
The first version of any new design is worse than the old one. Here it is worse in shadow, where nobody sees it.
Run last release against this one. Catch the cases your tests miss, on every release.
A ledger your agents build from and your new engineers read: who decided what, and why.
Coverage of real traffic, parity, open differences by severity, and cost and latency against the champion.
A ten-year-old platform where every change touches ten others, a major refactor, or a stalled migration.
Products whose value depends on AI models, hardware or training data that change faster than the code can follow.
Every app an agent builds needs a way to prove its next version before users see it.
Not for a simple product that ships small changes well.
A proxy Worker in front of the app captures each request, so request capture needs no change inside the app. To record side effects, the app carries a small SDK. Each challenger build runs in its own Dynamic Worker: fast to start, nothing to pay at rest, thrown away when the cycle ends.
| Capture | A proxy Worker records each request with waitUntil, forwards it unchanged, and fails open. |
|---|---|
| Capture log | R2 for bodies, D1 for the index. |
| Challenger builds | Dynamic Workers, one isolate per build, loaded on demand. |
| Replay | Workflows: paced, retried, and recorded runs. |
| Pairing | Durable Objects, one per request chain, with alarms for timeouts. |
| Compare and judge | Queues into the comparator, and AI Gateway in front of the judge model, with a spend limit per cycle. |
| Review | A portal behind Access, one per team. |
| Agents | An MCP server that gives the building agent the ledger and the open differences, and nothing it should not write. |
Today: the ledger format and CLI. The Workers pipeline is step 6 of the build.
Parts of this are already proven. Lovable runs every app as its own Worker behind one proxy that picks a build per route and per user. Add mirroring to that proxy and a judge behind it, and any platform where agents ship apps on Workers can give every app a challenger.
In every large AI rewrite so far, agents wrote the code fast. Proving it right took far longer.
11 days to write a 535,000-line port to Rust with 64 agents. About four months to ship it. 19 regressions got past a test suite of over a million assertions.
InfoQ, 2026AI wrote about 80% of a large code migration in Ads. Google then slowed generation down, because human review could not keep up.
Google, 20253,500 test files migrated in six weeks, on work estimated at a year and a half.
InfoQ, 2025Every product is built with what its team knew and had on the day it started. Ask what you would build today, with what you now know and the models and hardware you now have, and the answer is rarely what is running. Incremental change cannot get you there, because every step starts where the last one stopped.
In 1986 Richard Foster drew the S-curve: every technology improves slowly, then fast, then flattens near its limit. Going higher means jumping to a new curve, and the new curve starts lower. That dip is why incumbents stay on the old curve too long, and why attackers, with nothing to protect, win the jump. The way out is to be your own attacker: climb the new curve in shadow while the old system keeps serving. Until now that meant a second engineering team. Agents remove most of that cost. What is left is the proof.
Tesla has run this pattern on its driving stack since 2016. Its first self-driving software ran in shadow mode, with the human driver as the champion and every disagreement logged. Its HW3 computer puts two independent chips on one board, each planning from the same cameras, compared before the car acts. Tesla's own slide for it is titled Compare. Formula 1 teams build next year's car while racing this year's.
They write code. Adaptive Factory also proves each build on your live traffic before it takes over, and keeps rebuilding as your models, hardware, data and requirements change.
Request capture needs no change: a proxy in front of the app records it. Recording side effects, such as emails, payments and outbound calls, needs a small SDK inside the app.
Declared fields are masked before anything is stored, the same way on every replay. Each team gets its own capture store and ledger, behind Cloudflare Access.
Any. Adaptive Factory is stack agnostic. Capture sits in front of the app, and the SDK is a small contract: record what each request did, and swap outbound calls for recorders in shadow. The champion can run on any stack, and the challenger can be built on a different one.
The ledger format, its checker and the CLI. The build status below shows what comes next, in order.
Pick one system. We start with the steps that pay back before any rebuild exists.