At GitHub Universe, GitHub introduced a Git storage architecture that it says can sustain thousands of writes per second while scaling reads on demand. In internal testing, the platform supported 5,000 concurrent agents on a single repository sending 7,200 pushes per second, with read traffic served at consistently low latency. The work has been running underneath GitHub.com throughout its development, and GitHub positions it as the foundation for agentic development at the scale of hundreds of millions of developers.

Two principles have driven the design since GitHub first outlined it: minimize coordination, and decouple storage from compute. A previous post in the series described moving 99.99999% of repositories into Azure, scoping the write quorum to individual references, and standing up virtual replicas backed by Azure Blob Storage. The underlying observation is that very little of a write actually needs to be ordered. Git objects are immutable and named by their contents, so two writers can store them simultaneously without agreeing on anything. Only the reference update requires agreement, and it is tiny by comparison. Because of that, storing data, serving requests, and maintaining repositories can scale independently. From the client's point of view nothing changes: push, fetch, and branch work as before, with the same protections in place.

Two axes of scale

GitHub frames platform scale along two dimensions. Horizontal scale is how many developers and agents can work across many repositories; many existing approaches here — partitioning tenants across infrastructure, isolating or fairly enforcing tenant traffic, and load-aware routing — carry forward to the new architecture. Vertical scale is how many developers and agents can work on a single repository. Because agents write more code, individual repositories are expected to get larger and busier, so most requirements came from the vertical axis.

The busiest repositories on GitHub.com currently see at most dozens of writes per second, usually in short bursts. As parallel, round-the-clock agents take on more of that work, GitHub expects those bursts to become a sustained rate within the next year. Each push also multiplies reads: CI runs, deployment systems pulling the new commit, and other agents fetching it for context, all of which scales with write traffic. That pattern is already visible at the top of the curve — one repository's daily requests grew about 4x between March and May and has continued on an exponential trajectory since.

Line chart of daily requests to a single repository from March through May 2026. The March average is 44M requests per day and the May average is 181M requests per day, about a 4x increase.

Rather than plan for the next increment, GitHub set a target of at least two orders of magnitude more scale. For one repository, that meant the architecture had to meet a specific set of requirements.

  • Accept thousands of writes per second.
  • Support multiple writer nodes. Indexing incoming packs and checking object connectivity are the most CPU-expensive parts of a write and scale with write size, so a single node becomes compute-bound quickly; spreading the work across nodes also improves fault tolerance and shortens recovery after a node failure.
  • Minimize commit latency, since an agent waits on each push before starting its next step.
  • Record changes in order per reference while allowing fast linearization across references, so a lagging virtual replica can catch up by downloading only the data needed to serve the incoming request.
  • Keep reads cheap when nothing has changed — the common case given the read-to-write ratio.
  • Let each component scale independently.

The system also had to improve overall reliability and scale globally.

Project Rubicon and the data plane

Design work began in May 2026, shortly after the initial Azure migration. Several approaches were tried, all keeping pack data in Azure Blob Storage and some experimenting with reference state there as well. The chosen design, named "Rubicon" (a nod to the point of no return the industry crossed with agentic development), was selected to maximize throughput while preserving the correctness, durability, availability, and latency guarantees GitHub requires.

Above the data plane, much stays as it was. Requests from Git clients, the API, and the web UI still arrive at Spokes, which handles routing and load balancing and serves the internal API the rest of GitHub uses to read and write repository data. Spokes remains the placement and balancing service, maintaining the partitioning, isolation, and tenant fairness needed for horizontal scale. Everything underneath Spokes is new.

Architecture diagram. Git, API, and Web requests pass through Spokes to groups of virtual replicas per repository. Virtual replicas hold only cached state. Ref-CAS stores refs and the pack manifest, and Azure Blob Storage stores pack data. Compaction nodes compact and garbage collect packs in Blob Storage and update the pack manifest in Ref-CAS.

Spokes routes each request to one of a small group of virtual replicas assigned to that repository. A virtual replica is disposable compute that serves reads, writes, or both, and its local disk is a cache that can be rebuilt at any time. Spokes sends a repository's traffic to the same replicas when possible to keep caches warm and latency low, but correctness never depends on which replica handles a request. If one goes away, the repository's other replicas keep serving while a replacement fills its cache as traffic arrives. Busy repositories get more virtual replicas. Pack merging and removal of unreachable objects happen off to the side on a separate fleet of compaction nodes, which work directly against Blob Storage and Ref-CAS, leaving replica CPU and memory almost entirely for serving requests.

Durable state lives in two places: Git objects, as packs plus auxiliary read acceleration data, in Azure Blob Storage; and references plus the pack manifest — the list of packs making up the repository — in Ref-CAS, a separate replicated log service whose name stands for "Reference Compare-and-Swap."

The two paths through the system are straightforward:

  • Write: a virtual replica indexes the incoming pack and uploads it to Blob Storage, then commits a single Ref-CAS transaction that lists the pack in the manifest and updates the references. Compaction nodes later merge that pack with others to keep reads fast.
  • Read: a virtual replica checks its reference version with Ref-CAS, pulls the needed packs from Blob Storage into its cache, and serves the read from there.

Many other choices sit inside the architecture, from the software stack on the virtual replicas to how traffic routing and workload scheduling are tuned for different cases such as many small repositories versus one large one.

Reference state as the coordination bottleneck

Azure Blob Storage handles most of the new architecture's durable data well. Immutable, write-once objects spread across many keys are its natural workload, and nearly everything durable lives there:

  • Packs and indexes produced by pushes, compaction, and garbage collection.
  • Read accelerators built from those packs by the maintenance process — multi-pack indexes, reachability bitmaps, and some custom formats.
  • Records that let compaction and garbage collection resume or audit their work, plus the leases compaction nodes use to claim work.
  • Cached responses for frequently repeated fetches.
  • Checkpoints of the repository's reference state, though not the authoritative state used to serve requests.

References break that pattern: a small, frequently mutating set of state that many writes race to update. Conditional writes give a compare-and-swap for free, so object storage works up to a point, but two prototypes exposed the trade-offs.

Two prototypes and their ceilings

A write-ahead log indexed by a single blob made every update a conditional write against that blob. Reads are cheap — a virtual replica checks whether the blob changed and stops there. Writes are not: only one conditional write to a blob can be in flight at a time, so even batching every push that arrives during a write into the next one caps the repository at one write per round trip to a single blob. In practice that yielded write throughput in the mid-hundreds per second.

Splitting references across segment blobs, with each reference hashing to one of them, removed the cross-segment write dependency and raised the ceiling. Reads, however, now have to check every segment and run at the speed of the slowest one. The trade was write latency for read latency, and reads outnumber writes by orders of magnitude.

Ref-CAS: a dedicated log for references

The replacement is a replicated log service dedicated to references — Ref-CAS — run as a small consensus group. Each reference update is a compare-and-swap committed by a quorum: a transaction locks only the references it touches, verifies each still holds the value the writer expects, and becomes visible once a majority of replicas record it. Agents mostly push to their own branches, so most updates don't contend and replicate in parallel; when two pushes update the same reference, only one appends to the log.

Every commit gets a log sequence number (LSN), and the repository's version is the LSN of its latest commit. A read begins with a version check: the virtual replica sends the version of the reference state it already holds, and if that version is current the reply carries no references at all, so an unchanged repository costs a single comparison. A replica that is behind receives the current references and version plus pointers to pack data and other needed details, such as when the last garbage collection cycle ran.

Ref-CAS never holds or validates object data, unlike the consensus group in the legacy architecture — only pointers to it. A virtual replica uploads a push's pack to Blob Storage before committing the reference transaction, so a reference only ever points at objects that are already durable.

With this design, reference transactions run in the tens of thousands of operations per second, and annotations on the replication log give reads a baseline for deciding what to download per request.

Background compaction on separate nodes

Thousands of writes per second to one repository creates a second-order problem: keeping reads and writes fast. Every push adds a pack, and each additional pack makes lookups slightly more expensive, so the pack count can't grow without bound. In the legacy architecture, compaction runs on the same replicas that serve traffic and must run on every one of them. Now it runs entirely in the background on separate nodes, directly against durable storage, with Ref-CAS notifying virtual replicas of the evolving state.

Compaction nodes claim ownership of a subset of repository data via a lease, which lets compaction scale horizontally. One node walks a single shard of a repository's packs as follows:

  1. Lease the shard in Blob Storage, so only one node compacts it at a time. Virtual replicas keep uploading packs and listing them in the pack manifest.
  2. Read the manifest for new packs and collect them into an open segment — a holding area for data about to be compacted.
  3. When the segment hits a limit based on pack count, size, or age, seal it against new packs and combine its packs into fewer, larger ones. The shard's next segment can start capturing input packs while this happens.
  4. Before publishing, verify the new packs contain exactly the same objects as the inputs, then upload them and add them to the manifest.
  5. A second transaction removes the inputs from the manifest; cleanup deletes them later.

The process runs independently across many shards at once. Each pack's hash maps to a shard, so adding shards and nodes adds compaction throughput. A compacted pack still under the size limit returns to a shard by its own hash and merges again, so packs grow in tiers until they reach the limit — an effectively flat pack count as pushes climb, with a consistently flat latency curve as writes increase.

Garbage collection removes objects nothing references anymore, such as those left by deleted branches and force-pushes. It mirrors compaction: dedicated workers handle the compute-heavy portion, with special behaviors for safely removing data that warrant separate discussion.

Planned work

Each component scales independently: reads and writes by adding virtual replicas, reference ordering per reference rather than per repository, maintenance by adding compaction nodes. The goal is one architecture for every repository, from a lone side project to the busiest monorepo, with no special handling — and every improvement reaching every repository at once. Further optimizations to compaction and garbage collection are planned.

Architecture

  • Read only what's needed. Fetch a single object from Blob Storage instead of the whole pack holding it.
  • Organize packs by type. Group commits, trees, and blobs into their own packs so many requests touch less data.
  • Partial replicas. Serve requests without every pack on local disk.
  • Materialized views. Keep data ready to use — prepared archives, a near-live shallow copy of the default branch, agent session context stored alongside each commit.
  • Global replicas. Place replicas in any region near the workloads using them, with reads within bounded staleness of the latest write.
  • Scale to zero. Grow and shrink the fleet with the repositories actually active.

Agent operations

  • Work without a clone. Many agent tasks need a handful of files and context, not a full working tree; both can be read straight from the server.
  • Atomic commit API. Land a multi-file change in one operation that commits entirely or is rejected cleanly on conflict.
  • Event streams. A generic stream agents and surrounding systems subscribe to for real-time changes.

Git itself

  • Lightweight clones. Partial clone, shallow clone, and sparse checkout each let an agent fetch less, each has gaps, and they don't always work well together; the work is to improve each and make them fit.
  • Remove hidden scaling costs. Git still has code paths that slow down much faster than repositories grow. Recent releases fixed several; more are expected.
  • Faster history walks. Metadata such as the commit-graph answers merge-base and reachability questions without walking every commit — most valuable when an agent's API call becomes Git work on the server.
  • Avoid common gotchas. Git can catch more of the mistakes agents make, as developers do, and warn before damage occurs.

The architecture is in a limited private preview now, with a broader rollout early next year.