GitHub says per-reference write ordering gave 3–4x higher Git throughput in internal tests, the step that moves its last busy repositories to Azure
A 21 October engineering post says a copy of 99.99999% of repositories is already in Azure; the remainder depends on letting writes to different branches proceed in parallel. Verdict: relevant if your agents push to shared repos at volume, but the numbers are GitHub's internal tests and the post ends with write throughput still the open limit.
In internal testing with realistic traffic, writes to different references consistently saw 3–4x higher throughput at lower latency.
Comprehensive take
A credible engineering explanation of why agent-heavy repositories hit write limits and what GitHub is doing about it. The 3–4x figure is GitHub's own internal result with no published methodology; wait for the follow-up post before planning around it.
Use cases
Teams running many parallel coding agents
Give each agent its own branch. GitHub's described fix lets writes to different references proceed concurrently, while writes to the same reference still serialize.
Platform engineers designing Git hosting
The post is a worked example of replacing a repository-wide write lock with per-reference ordering and of moving read replicas onto object storage.
Anyone watching the Azure migration
GitHub says a copy of 99.99999% of repositories is in Azure and describes the mechanism for the busiest remainder; no completion date is given.
Specs
| Repositories copied to Azure | 99.99999% (GitHub's figure) source |
|---|---|
| Typical replica count | Five per repository source |
| Cross-region round trip | About 25 ms, about 1,000 miles from existing data centers source |
| Reported write gain | 3–4x throughput at lower latency for writes to different references, internal testing source |
Insights
- Axion reading: the gain depends on writes landing on different references. Workloads where many agents update one shared branch should not expect the multiplier.
- Axion note: no absolute throughput, latency or repository-size numbers are published, so the 3–4x cannot be reproduced or compared with other hosts.
- Axion note: the post says write throughput remains the next limit and a follow-up is due, so this is a mid-series status report rather than a finished design.
What GitHub changed
In a post dated 21 October, GitHub engineers Eleanor White and Victoria Dye describe the "bridge" between the company's current Git storage design and the one it wants for agent-scale development. The headline claim is that a copy of 99.99999% of GitHub's repositories has already been moved to Azure, and that one specific change to how writes are ordered is what brings the rest across.
The problem they describe is concrete. GitHub's storage layer, Spokes, keeps most repositories on five replicas. Its quorum only needs a majority to commit a write, but it waits for every healthy replica to respond, up to a timeout. The post says the slowest healthy replica therefore sets the latency of every write, and because each write holds a repository-wide lock until it commits, it also sets the throughput ceiling. Once a replica sits in the target Azure region, roughly 1,000 miles from GitHub's data centers, each network round trip costs about 25 ms, and a write needs several. A repository already near its ceiling would fall further behind with every push.
The fix: order writes per reference
The change is to serialize writes per reference (a branch or tag) instead of per repository. Only writes that contend on the same reference wait for each other. The post argues most writes touch different references, for example agents and developers each pushing to their own branches, so they can now be in flight at once. Each write still pays the cross-region latency, but that latency stops being a single shared bottleneck. GitHub says the ceiling rises roughly in proportion to how many references are being written at the same time.
The only measurement given is the one quoted above: in internal testing with realistic traffic, writes to different references saw 3–4x higher throughput at lower latency. The post does not publish the test setup, repository sizes, absolute throughput or latency figures, so treat the multiplier as a vendor-reported result under unspecified conditions.
Reads scale separately
The second half covers reads. The post describes "virtual" replicas backed by object storage that keep no persistent state of their own. It says GitHub's distributed load-testing harness routinely found ceilings in the current architecture, but against virtual read replicas the harness hit its own limits first. That is a statement about the test tool, not a measured read ceiling, and no figure is given. A virtual write replica also coalesces transactions on disjoint references into one set of network I/Os to object storage, and for now handles compaction, which read replicas inherit.
What is still open
GitHub is explicit that this is not the end state. The post says the quorum remains the bounding factor and that write throughput is the next limit, because every write still waits on replicas that each hold a full copy of the repository. It points to a final post in the series, promised for the following week around GitHub Universe, covering the end state and why a small consensus group remains in the stack.
Why practitioners should care
If you run coding agents that open many branches against one repository, the bottleneck GitHub describes is the one you would feel as slow or queued pushes. The per-reference change helps most when your agents write to separate branches. It helps little if they all update the same reference, since contending writes still wait for each other by design. Teams should also note that GitHub frames all of this as infrastructure in progress, with no customer-facing performance commitment in the post.