When you run a routine git push in your terminal, it feels like your changes just drop into a folder on some remote server. Behind the scenes at GitHub, though, an internal router and storage coordinator called Spokes kicks in: it accepts packed objects, fans them out across independent servers in different halls, and makes sure every node commits the new repository state in sync. For years, that machinery stayed invisible because humans set the pace—write some code, test it locally, push a branch for review.
Everything changed with autonomous AI agents. Dozens of bots without coffee breaks spin up branches in parallel, run tests, and push fixes like machine-gun fire. GitHub engineers Eleanor White and Victoria Dye pulled back the curtain on this "agentic shift" in their breakdown of the new storage architecture, which was spotted by the DevOps&SRE Library channel. How do you scale a platform the size of GitHub when autonomous agents generate a nonstop flood of commits and lock up the busiest repositories?
Physical Data Center Limits and the 25-Millisecond Wall
The explosive surge in AI agent traffic (I recently covered how neural assistants boost commits per engineer more than fivefold over six months in my breakdown of the Anthropic study) hit a hard physical wall. GitHub's data centers and the regional power grid maxed out their electrical capacity, and hardware supply chains couldn't add racks on-site fast enough. There was enough headroom to migrate safely to Azure, but no time to waste. Because Git operations on GitHub are Tier 0 critical, the team refused to change both hosting and storage architecture under rising load at the same time: first they moved the data as-is, planning to rebuild the architecture once inside the cloud.
In August 2025, the first repository copy landed in the Azure Central US region. Most repositories run as a 5-replica quorum: today 2 of the 5 replicas live in Azure, serving roughly half of all Git traffic, while preferential routing in Spokes directs reads to a replica in the same region and availability zone.
By October 2026, GitHub had replicated 99.99999% of its repositories to Azure—yet the remaining 0.00001% of the hottest projects got stuck. One detail in the report immediately caught my eye: a single physical constant was holding them back. The target Azure region sits about 1,000 miles from GitHub's data centers, so a single network round trip takes around 25 ms, and every Git write requires multiple packet exchanges. For a repository already running at max throughput, those 25 ms at every step became an impenetrable wall.
From a Repository-Wide Lock to Per-Reference Quorums
Why did cross-region latency hit writes so hard? Formally, a Spokes quorum only needs a majority (3 of 5 nodes) to confirm a write, but in practice it waits for every healthy replica up to a timeout so distant servers don't fall behind. That means the slowest replica across the 25 ms link dictates the latency of every write. Worse, under the old design, each write grabbed an exclusive repository-wide lock for the entire duration of those network round trips.
Picture a thousand-office business center with a single set of keys at the front desk for the whole building. While one courier takes the keys up to room 101 on the tenth floor and walks them back to security, twenty other couriers are stuck waiting at the turnstile—even though they just need to drop off packages in completely different offices on the ground floor.
Let's trace this traffic jam in a working Spokes cluster of 5 replicas (3 in the local data center and 2 in Azure with a 25 ms round trip). Suppose 20 autonomous AI agents are working in parallel on isolated branches agent/task-1…agent/task-20 in a busy repository, and at that exact second a developer pushes an urgent fix to hotfix/login or a commit to main. With a global lock, only one write can be in flight: the developer gets queued behind all twenty agents, waiting for each one to finish several 25 ms round trips to Azure. The queue backs up, and pushes start timing out.
You might reasonably ask: why lock the entire repository when the agents and the developer are touching different branches? That's where GitHub's first architectural principle comes in—minimize coordination: don't serialize what doesn't need to be ordered. In Git, consistency guarantees apply per individual reference (like refs/heads/main): once a branch updates, no client can ever see its old value, whether it's a fast-forward, a force push, or a deletion. Updates to separate branches, however, don't depend on each other at all!
Moving Spokes to per-reference serialization took the padlock off the front door. In our scenario, agent/task-1…agent/task-20 and hotfix/login fly across the 25 ms bridge to Azure in parallel, and only competing pushes to the exact same branch wait on each other. In internal tests on realistic traffic, this boosted write throughput 3–4x with lower latency and cleared the path to Azure for the final 0.00001% of ultra-active repositories.
Virtual Replicas and Offloading Storage to Azure Blob Storage
The next step was taking the pressure off reads. In a typical repository, every single write is outnumbered by 100 to 1,000 reads (git clone, git fetch, CI builds, and agents reading code). Previously, both streams hit the exact same 5 replicas: reads crave a large RAM cache, yet background compaction eats that same memory.
GitHub's second principle is decouple storage from compute. Engineers introduced a stateless, ephemeral virtual write replica into the Spokes quorum. It doesn't serve reads; instead, it streams writes into Azure Blob Storage and confirms the commit to the quorum once the data is safely persisted in the cloud. Even better, the virtual write replica performs transaction coalescing: it bundles parallel commits from independent branches (all 20 of our agents plus hotfix/login) into a single network I/O batch to Blob Storage. The repository pays for one network trip instead of twenty, while that same node handles file compaction.
Once the authoritative data lives in Azure Blob Storage, the platform can spin up as many virtual read replicas on demand as it needs. They sit outside the write quorum: each node warms its local cache straight from Blob Storage (already getting compacted state) and reconciles changes with cloud storage in the background. Reading through their internal benchmark results, one detail really stood out to me: GitHub's distributed load generator, which used to hit the ceiling of the old architecture, ran out of its own capacity before the virtual read replicas even flinched.
Immutable Git Objects and the Road to the Next Billion Repositories
This transitional architecture still has boundaries. If dozens of agents push simultaneously to a single shared branch like refs/heads/main, they still have to wait in line and deal with rejected non-fast-forward pushes. Also, background reconciliation for virtual read replicas doesn't fit every workload: when you need an immediate read right after a write, reconciliation switches to synchronous in-line reconciliation, pulling only the changed references and data.
Today Spokes handles over 100 billion operations a day and runs background recovery ("sweepers") across a billion repositories, but a protocol built around full repository copies won't survive the next billion projects. Fortunately, Git's core objects (file blobs, trees, and commits) are immutable and content-addressed by hash (the same model that lets distributed issue trackers like git-bug live inside the object tree). You can persist them in parallel without any voting.
Only the tiny mutable reference pointer needs strict ordering in time. As engineers Karthik Raman and Brian Selenza explain in their overview of the target architecture Project Rubicon, a lightweight consensus service called Ref-CAS (Reference Compare-And-Swap) takes care of atomically updating a replicated reference log while an isolated worker pool compacts packfiles in the background. That pipeline is built to handle up to 5,000 autonomous agents and 7,200 pushes per second into a single repository.
To me, GitHub's journey is a clear preview of where developer infrastructure is heading: when autonomous agents turn writing and testing code into a 24/7 assembly line, storage engines have to drop global locks. On the road to the next billion repositories, the winning design separates the immutable sea of objects from a tiny core of mutable state—and synchronizes across the network only the few bytes that truly require coordination.

