A software factory that builds tomorrow's version today.

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.

The same requests reach the champion and the challenger. Only the champion acts. Both results meet at the comparison. Live traffic Champion what runs today, serving users Challenger the new build, in shadow Compare and rule
Every request reaches both builds. Only the champion acts. The challenger's emails, charges and API calls are recorded, not sent. Every difference gets a ruling, and every ruling is kept.

Verdicts

    Five parts. One loop.

    Each cycle starts with what the last one learned.

    1. 01Charter

      Why rebuild, written before any code: what changed, what limit the champion hit, and the measure the challenger must beat.

    2. 02Ledger

      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.

    3. 03Build

      Agents write the challenger: a fresh build of the whole system from the ledger, not a patch on the old code.

    4. 04Prove

      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.

    5. 05Promote

      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.

    Other software factories build once. This one checks its own work in production.

    The proving ground is what makes it safe to let agents rebuild a system people depend on.

    Real traffic, not only tests

    Tests check what someone thought to check. The proving ground checks what your users actually do, including the long tail where rebuilds break.

    Safe by construction

    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.

    Compared on meaning

    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.

    People rule on what matters

    The judge clears the bulk. Your team decides the cases that touch money, safety or trust, and those rulings train the judge.

    It keeps rebuilding

    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.

    No dip for customers

    The first version of any new design is worse than the old one. Here it is worse in shadow, where nobody sees it.

    Useful in the first weeks, before any rebuild

    A release check on real traffic

    Run last release against this one. Catch the cases your tests miss, on every release.

    A written spec of the system

    A ledger your agents build from and your new engineers read: who decided what, and why.

    A scorecard

    Coverage of real traffic, parity, open differences by severity, and cost and latency against the champion.

    For systems that have outgrown their design

    A system near its limit

    A ten-year-old platform where every change touches ten others, a major refactor, or a stalled migration.

    Inputs that change fast

    Products whose value depends on AI models, hardware or training data that change faster than the code can follow.

    Platforms where agents ship code

    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.

    Built on Cloudflare, where the traffic already is

    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.

    CaptureA proxy Worker records each request with waitUntil, forwards it unchanged, and fails open.
    Capture logR2 for bodies, D1 for the index.
    Challenger buildsDynamic Workers, one isolate per build, loaded on demand.
    ReplayWorkflows: paced, retried, and recorded runs.
    PairingDurable Objects, one per request chain, with alarms for timeouts.
    Compare and judgeQueues into the comparator, and AI Gateway in front of the judge model, with a spend limit per cycle.
    ReviewA portal behind Access, one per team.
    AgentsAn 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.

    Why now: writing got cheap. Proof did not.

    In every large AI rewrite so far, agents wrote the code fast. Proving it right took far longer.

    Bun

    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, 2026
    Google

    AI wrote about 80% of a large code migration in Ads. Google then slowed generation down, because human review could not keep up.

    Google, 2025
    Airbnb

    3,500 test files migrated in six weeks, on work estimated at a year and a half.

    InfoQ, 2025

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

    Read the full thesis: The Adaptive Factory

    Two S-curves. The champion flattens near its ceiling. The challenger starts lower and climbs past it in shadow. Champion near its ceiling the dip, in shadow Challenger Effort over time
    The next curve starts lower. The challenger climbs it in shadow, so customers never use the weaker early version.
    Tesla Autonomy Day slide titled Compare: the HW3 board with its two chips highlighted and arrows passing results between them
    Two chips, one board, the same cameras, compared before the car acts. Image: Tesla, Autonomy Day 2019.

    Questions

    How is this different from a coding agent or another software factory?

    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.

    Does my app 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.

    What happens to personal data?

    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.

    Which stacks do you support?

    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.

    What works today?

    The ledger format, its checker and the CLI. The build status below shows what comes next, in order.

    Start with one system

    Pick one system. We start with the steps that pay back before any rebuild exists.

    1. Capture a slice of its real traffic, with personal data masked.
    2. Write its ledger with your team: what it must do, who decided, and why.
    3. Run last release against this one, so every release gets checked on real traffic.
    4. Then rebuild one part with agents, in shadow, and promote it only on evidence.

    Where the build is

    1. 1Ledger format, checker and CLInow
    2. 2SDK inside a first production app
    3. 3Capture, replay and compare, last release against this one
    4. 4Judge and review queue
    5. 5First challenger, written by agents from the ledger alone
    6. 6Pipeline on Workers, running continuously
    7. 7Scorecard, promotion gate and live mirror