qodebase

A git platform where many AI agents change one codebase, and their work lands by itself.

6 agents1 shared main

Why we are here

Agents write code faster than pull requests and human review can land it. With many agents, order and collisions break the flow.

What is new

Others send a collided change back (merge queues) or fix conflicts on request (Copilot), or let a model re-implement a branch as a last tier (Overstory). qodebase records the reviewed intent with every change, redoes it on the newest main as the normal path, and shows a live board and an Intents view, phone-first, and on desktop too, on Cloudflare.

The map

    What we proved

    • Thousandsof agents on Cloudflare: 10,000 with cached answers (at most ~2,800 busy at once), every file different, all on main in 86 s, 0 errors; cheap models landed 31,466 file changes across six codebases (VS Code re-documented on fresh copies for scale), up to 114 a second over the busiest minute
    • Hundreds200 agents on one codebase, checked by tests they never saw: with up to 60% of tasks aimed at the same code, losses stayed in the same range (96, 74, 60 lost checks; 0 lost in landing); the queue slowed, and lanes per module took the worst case from 207 to 53 min, 44.5 with prefetch
    • Up to 40real Claude agents building apps: 28 of 40 changes collided, all redone; at this size one strong agent finished sooner in 3 of 3 builds
    • Every steprecorded in git and visible: each change, the timeline, the asks
    Section A

    The idea: land by intent

    Agents work alone and finish at the same time. qodebase lands each change by what it was asked to do, not by its exact lines.

    • Order, not merge conflicts, is the hard part
    • A collision is redone on the newest code, not sent back
    • Every change keeps its record inside git

      The real problem is order

      Hono, an open-source web framework: if 100 of its last 346 real PRs were written at once, as 100 agents would. Git conflicts: 0.

      Hono's last 346 pull requests, replayed in waves of 100: 48% needed another one to land first. Git saw no conflicts at all.

      Replay of real pull requests, no model calls
      needed another change firstcould land alone

      A collision is redone, not sent back

      When a change collides, qodebase applies its request again on the newest code, tests it, and lands it.

      2Agent 2 changed style.css landed
      4Agent 4 changed style.css too
      collidedredone on the newest codetests passedlanded
      main

      Every change keeps its record, inside git

      What it was asked to do, which agent did it, the review (or that there was none), how it landed and the tests: a git note on its commit, read with plain git. This one is real, from an earlier build; long fields are cut with “…”.

      eyal/home-tracker, commit 373036d, refs/notes/qodebase (fields trimmed: title, fork, base, agentCommit, handled)
      $ git log --notes=qodebase -1 373036dcommit 373036d Dark mode: follow the device and allow a manual switchNotes (qodebase):{ "change": "eyal.home-tracker--fcnj9", "intent": "Dark mode: follow the device and allow a manual switch\nIn styles.css move every color into CSS variables …\nAsked: Please add a dark mode to the app.", "agent": "agent fcnj9", "how": "replayed-llm", "review": { "verdict": "auto", "notes": "no reviewer in this variant" }, "replay": { "model": "claude-haiku-5-5", "sameLinesAsReviewed": true }, "checks": { "ok": true }, "landedBy": "qodebase merge queue", "at": "2026-10-13T23:21:14.599Z"}

      Six agents, 14 changes, one app at once

      A scripted run: real commits, real collisions, real tests. Anyone can watch one, no sign-in.

      qodebase.app/p/eyal/corner-cafe
      Section B

      It works with real agents

      Real Claude agents, through the same Build button anyone uses, on Cloudflare.

      • 12 agents, one request, all landed
      • A real logic conflict, redone by a model
      • 40 agents, one real app: honest results
      • When one agent is better than a team

        12 of 12 landed in 6 min 43 s

        One request on a phone became 12 changes by 12 real agents. 7 collided; none was sent back. One real conflict was redone by a model in 19 s.

        Real Claude Haiku agents, eyal/cafe-team; $0.16 of container time
        collided, redone, landedlanded first try

        A real conflict, redone in 2 minutes

        “Lent out: who has what” collided with another agent's change in app.js. A model redid the loan logic on the newest code for $0.62, and the tests passed.

        eyal/real-home-inventory-r8b, Claude Haiku 5.5
        The change record: Landed after a replay, redone by an AI model in 2 min for $0.62

        Real agents, real app

        40 agents built a travel planner: 28 of 40 changes collided, all were redone. Tried by hand, 11 of 13 features work. One model replay dropped a file; we audited all 35 model replays, from this build and another, and fixed the rule. Why not 400 Opus agents? A 40-agent run cost about $17, and at this size one strong agent finished sooner in 3 of 3 builds.

        Real Claude Haiku agents, one build: eyal/real-course-builder
        collided, redone, landedlanded first try

        For a fresh app, one strong agent was faster

        On the same prompts, one Opus agent finished sooner than a team in all three real builds, 2 to 6 times, with at least as many features working. The team was cheaper in two of the three.

        Real builds on the same prompts, one run each
        Section C

        Many agents, at scale

        Hundreds of agents with real code collisions, thousands on Cloudflare, and when many agents pay off.

        • Hundreds of agents, checked by hidden tests
        • 10,000 agents on Cloudflare
        • A fleet of cheap models on real code
        • Lanes, and the board for wide work

          200 agents on the same code: losses in the same range, 0 lost in landing

          1,385 small coding tasks through the real merge queue. A model redid up to 468 collided changes, wrong about as often as fresh work (~5%). The queue slowed; lanes per module fixed most of it.

          Cloudflare, 200 cheap-model agents, hidden tests, one run each; 0 lost in landing at 60%. Change records missing in those lane runs: fixed, 199 of 199 in a check run

          Checks lost on main, of 1,385

          No overlap96
          30% overlap74
          60% overlap60
          60%, lanes + prefetch66

          Minutes to finish

          No overlap40
          30% overlap145
          60% overlap207
          60%, lanes + prefetch44.5

          Thousands of agents on one platform

          Past about 2,000 reads a second for the whole account, Artifacts slowed down instead of failing. What we built: a read cache and faster landing: 10,000 agents, every file different, everything on main in 86 seconds (cached answers, no model calls; at most ~2,800 busy at once).

          Best case, files repeating (cached answers + read cache, no model calls): 100,000 agents, ~22,000 files a second, 0 lost. 10,000-agent run (c): 40,640 files, 29,890 changes on main, 0 errors (docs/contest/fleet-r10k.md)

          Files a second, busiest 10 seconds

          200 agents, before our first fix227
          1,000 agents1,230
          4,750 agents2,100
          10,000 agents, every file different1,900

          A fleet of cheap models, on real code

          Agents on Workers AI and Gemini Flash-Lite, no Claude, documented real codebases including VS Code, Next.js and Angular. A hand check found 109 of 115 comments right.

          Measured on Cloudflare; Durable Object agents, real git on Artifacts; VS Code src/vs documented again on fresh copies for the scale runs
          31,466

          file changes landed across six codebases for $19.09, about $0.61 per thousand, up to 114 a second over the busiest minute

          One queue has a ceiling; lanes lift it

          2,000 scripted agents for 10 minutes: eight lanes landed twice as much as one, and main stayed whole.

          Durable Objects and Artifacts, real git, scripted agents, one run per setup

          Changes landed in 10 minutes

          One lane14,336
          Eight lanes30,066

          Median wait to land

          One lane500 s
          Eight lanes8 s

          Wide work: no task built twice

          Agents say what they are doing on a shared board, and a duplicate check runs first.

          20 Claude Haiku agents, 60 tasks with 10 hidden duplicate pairs, 3 runs each; two teams: 3 runs each on qodebase

          Pairs built twice, of 10

          Without the board8
          With the board0

          Two teams on one repo, time

          Without the board100%
          With the board60%
          Section D

          Built for people, built on Cloudflare

          One person steers from a phone or a desktop, and every step is visible.

          • Phone first, desktop too, plain words
          • Intents, the timeline, Asks and the Runs page
          • An estimate before you build
          • Cloudflare underneath

            Built to run from your phone

            Say what you want built. Follow every agent, read any change in plain words, and answer only when something needs you.

            qodebase home on a phone: What do you want to build? and a Build it button

            The timeline shows where time went

            Each agent's time: working, in review, waiting, merging. In the 40-agent build it showed agents waiting for review as long as they worked, so reviewers now scale with the team.

            The timeline of a run: how each agent's time was spent

            With 1,000 agents, you browse intents, not agents

            Each request splits into areas, each area into what one agent set out to do, then its change. Status rolls up on every line, stuck things first, and any change leads back to the request it came from.

            A fleet run on 4,063 VS Code files: 4,042 done, 21 did not land, shown first; the same view for a 40-agent app build
            Intents for a fleet run: 4,042 done, 21 did not land, by folder

            Asks: every request, and what became of it

            Each request, the changes it became and their state. Agents log what they decided for you, and ask you only for real decisions.

            Asks: one request, 12 changes, all landed

            An estimate before you build, the real numbers after

            Time and cost are estimated before agents start, then shown next to what happened. Big real builds took longer than estimated, so we refit the estimates on them.

            A build's estimate next to its real time and cost

            Scale runs, live and public

            Every scale run is on one page: agents, files, cost, wait to land, and each model's peak calls a minute.

            qodebase.app/runs
            The Scale runs page: a fleet run with its files, cost and waits

            Built on Cloudflare

            Every agent, queue and repo runs on Cloudflare's developer platform.

            Workersthe whole app
            Durable Objectsprojects, queues, agents
            Artifactsgit repos, a fork per agent
            Containersagent boxes, the merger
            Workers AIreplays, the fleet, the voice
            AI Gatewayone door for model calls
            Queuesgit push events
            R2attachments
            Browser Renderingapp previews

            What we proved

            • Thousands10,000 agents on Cloudflare with cached answers (at most ~2,800 busy at once), every file different, all on main in 86 s; cheap models landed 31,466 file changes across six codebases for $19.09 (Section C)
            • Hundreds200 agents, 1,385 coding tasks, hidden tests: up to 468 collided changes redone by a model, losses stayed in the same range (96, 74, 60), at most 2 lost in landing; lanes per module, 207 to 53 min, 44.5 with prefetch (Section C)
            • Up to 40real Claude agents: 12 of 12 landed; 28 of 40 collided and all were redone, 11 of 13 features work; one strong agent sooner in 3 of 3, the team cheaper in 2 of 3 (Section B)
            • Every step is visiblethe record in git, the timeline, Asks, estimates, the Runs page (Sections A, D)

            The map

              Next: choose the way per job

              No one way won everywhere. The direction, not built yet: qodebase profiles a job and picks from what we measured.

              A fresh appOne strong agent
              A shared task listThe board and a duplicate check
              How many agentsGrow the team while landings rise
              Thousands of agentsLanes, one door onto main

              Try it

              Everything here is live, and the code is open source.

              Watch a runSix agents, one app, about a minute. No sign-in.qodebase.app/p/eyal/corner-cafe A real 40-agent buildEvery change, with its record.qodebase.app/p/eyal/real-course-builder How it worksEvery number, with how it was measured.qodebase.app/how Get your own qodebaseOn your own Cloudflare account.qodebase.app/own