GitHub was built for a handful of people per repository, each opening a branch, writing a diff and asking another person to read it. Put 100,000 agents on one codebase and every one of those habits breaks. Signalbox treats agents as trains, the codebase as track and the human as the signaller: the person who grants blocks of track, sets routes and decides when two trains want the same line.
Written for Cloudflare's "Build the next GitHub" challenge: a new way for hundreds of thousands
of agents to work on changes concurrently. The screens use one invented repository, harbor/ledgerline,
a payments ledger, so each page tells part of the same story.
INT-4812, partial refunds on split-tender payments. A human touches it twice.
Each GitHub primitive encodes an assumption about how many people are working and how fast. Here is the assumption, where it fails, and what replaces it. Each replacement has a screen.
| GitHub today | Assumes | At 100k agents | Signalbox |
|---|---|---|---|
| Pull request | One author, one approach, and a person who reads the diff. | 64 agents open 64 PRs for the same goal. Nobody reads them, and the best ideas are spread across several. | Intent The goal is the unit. Attempts compete on evidence, are clustered by approach, and the best parts are grafted together. |
| Branch | Diverging is cheap and reconciling later is rare. | Possible collisions grow with the square of the agents. Rebase storms never settle. | Lease Claim the symbols before you change them, like a train taking a block of track. Conflicts are prevented. |
| Merge queue | Changes land one at a time behind CI. | 18,000 changes a day at 20 minutes of CI is 250 days of queue. | Main line Speculative trains run ahead in parallel. A failure is bisected and only the faulty change is shunted to a siding. |
| Merge conflict | Overlapping text is the danger. | The text merges cleanly and the behaviour breaks. Most agent collisions look like this. | Conflict room Detected by property tests and invariants. The two agents negotiate a fix; a person sees only policy questions. |
| Blame | Knowing who and when tells you why. | Who is a model, and when is three seconds ago. | Why Every line links to its intent, the session step that wrote it, the reasoning, the rejected options and the tests that pin it. |
| Review and inbox | A person reads every change. | Attention is the bottleneck, and an inbox with 18,000 items is the same as none. | Decisions An attention budget spent on judgement calls and a sampled audit. Measured defect rates set each fleet's autonomy. |
A diff is one guess at a goal. Store the goal, its checks and its budget; let diffs be cheap and many.
Pessimistic locking on symbols beats optimistic merging once the writers number in thousands.
Speculate ahead like a CPU pipeline, and roll back only the faulty change.
Detect them with properties and invariants, and make the agents that caused them fix them.
Sessions are versioned like code. You can replay any of them, or fork it from any step.
Budget it, sample with it, and let measured quality buy autonomy for each fleet.
Directions that fit the same model and would make good next screens.
Commits record what was done: rename a symbol, extract a function, add a parameter. Operations commute, so a rename by one agent replays cleanly over the work of 4,000 others instead of conflicting with all of it. Think CRDTs for code.
Priya owns "no money is ever a float" and "PII never reaches a log", wherever that code lives. Any change that touches an invariant's evidence routes to its owner, whatever directory it is in.
The repository keeps intents, specs and tests as the source of truth. Code is regenerated when a better model arrives or the spec changes, and the diff people read is the spec diff.
The 63 attempts that lost INT-4812 stay cheap and dormant. When the spec changes, they are re-scored first; yesterday's runner-up is often today's winner, at no new compute.
Fleets carry a record: landed changes, reverts, cost per landed change, specialities. Intents carry budgets, fleets bid on them, and repositories can hire the fleet with the best record on refunds code.
When a person opens a file to understand it, they take a short read lease. Agents queue their writes to that region until the person closes it, so the code never changes under their eyes.
A first sketch of where each part would live. To be checked against the Artifacts API before building.
| Part | Built on | Why it fits |
|---|---|---|
| Attempts and sessions | Artifacts repos | One repo or fork per attempt and per agent session, with a commit per step. Repos are cheap enough to make millions, and they speak git, so any agent can work in one. |
| Lease tables | Durable Objects | One object per module holds that module's leases. A single-threaded owner per region is exactly what a block signal is: strong ordering locally, sharded globally. |
| Trains and bisection | Queues and Workflows | Couple changes into batches, run stages, and bisect a failed batch as a durable, retryable workflow. |
| Running tests | Sandbox SDK | Each attempt and each train runs its checks in an isolated sandbox close to its repo. |
| Previews | Worker previews | Every attempt that passes acceptance gets a preview URL for the canary stage and for people who want to click through it. |