On November 2, 2026, OpenAI published an engineering post titled Scaling Git at OpenAI. It describes Pando, a new backend for Git repositories that OpenAI says now powers all development in its monorepo, the single large repository its engineers work in.
The reason is volume. OpenAI says its Codex coding agent lets engineers run far more work in parallel, which means more branches, pushes, merges, fetches and clones. Scaling Git for this kind of load is the central topic of the post.
This article summarizes the design, the tradeoffs OpenAI chose, the results it reports and what other teams can learn. All figures below come from OpenAI's own post. They are vendor-reported, and we have not tested them independently.
Why OpenAI replaced its source control backend
According to OpenAI , the systems behind its monorepo began struggling at around the end of the previous year. The company describes slow fetches and pushes, failed merges, and reliability that at times fell below 90%.
The post asks a direct question: had the company reached a limit of Git itself, or of the way it served its monorepo? It does not answer this as a standalone finding. What it does say is that OpenAI saw a way to keep the familiar Git workflow while rebuilding the backend.
The stated goals were two. The first was writes that scale horizontally, tuned for many concurrent pushes to different branches. The second was reads fast enough that clients can use all of their available network bandwidth.
OpenAI also says that staying compatible with Git let its engineers and agents keep their existing workflows. It adds that building on Git meant client improvements could be shared with the wider community.
Reported results
OpenAI reports the following for production use:
- Median push latency: cut by nearly 5x, which the post also describes as nearly 80%.
- Data delivered: nearly a petabyte of Git data per day.
- In a single hour: more than 57 terabytes of Git packs served in a single hour, with more than 99% of those bytes coming from local disk cache.
- Cache hit rate: over 99% for packfile requests routed to its Express caching servers.
- Network: clone and fetch operations that saturate 10 Gbps links on standard cloud virtual machines.
OpenAI also says merge reliability improved after the switch. Pando began serving production traffic in April 2026, according to the post.
How Git stores and moves history
To follow the design, it helps to know a few Git basics. Git records a repository as a graph of objects: blobs hold file contents, trees map names to blobs or other trees, and commits point to a root tree and their parents. Branches and tags are references, often called refs, that point to commits.
Objects can be stored loose, as individual files, or packed together in a packfile. A packfile is Git's format for compressing many objects, and it can store similar objects as differences against each other.
During a fetch, the client sends the server two lists of commits: the ones it is asking for and the ones it already holds. From those, the server determines which objects are missing and ships them as a packfile. A push goes the other way, and the pack the client builds can depend on objects the server already holds.
Replicating a repository therefore means keeping both objects and refs consistent across servers. It also means settling competing updates, such as two pushes that try to move the same branch to different commits.
The two common designs OpenAI compared
OpenAI modeled two conventional ways to scale Git service, and describes why neither fit its needs.
Three-phase commit
In this design, several replicas each hold a full copy of the repository. A push is copied to all replicas, and a majority must accept the ref update through several rounds of messages coordinated by one server.
The upside is that any replica can serve reads locally with a consistent view of all refs. The cost, per OpenAI, is that refs are updated one at a time, and disk speed and network latency sit on the push path. As write volume rises, replicas must absorb incoming packs as well as read traffic.
Write-ahead log
In the second design, a shared manifest in blob storage orders all updates. A server uploads the pack, then tries to add its ref update to the manifest using a compare-and-swap, an operation that replaces the manifest only if nobody changed it in the meantime.
Packs can upload in parallel, but even pushes to unrelated branches compete for the same manifest. Batching helps throughput but adds queueing delay. OpenAI also notes that replicas must read and index packs from the blob store, and can fall behind if writes outpace that work.
OpenAI ran a simulation of these approaches against Pando, with 1,000 clients each pushing to its own branch. The post labels it a synthetic teaching model, not a production benchmark. It reports that the modeled three-phase commit system showed much higher write latency under load, while the write-ahead log system showed higher read latency.
How Pando works
Pando gives up two things that most Git servers treat as required. One is a consistent point-in-time view of every ref across the repository. The other is a unique packfile built for each fetching client.
Writes: independent branches
When a client pushes, Pando streams the pack into blob storage and validates it along the way, without unpacking it into a local repository. It then records a ref version in a metadata store. A ref version holds the new tip, the pack that supplied it and any earlier versions the pack depends on.
Because each branch is coordinated on its own, pushes to unrelated branches do not wait on each other. The only contended item is the ref pointer, which is guarded by an atomic compare-and-swap-like operation. OpenAI says a write needs a constant number of metadata reads and writes.
The consistency model is causal rather than global. Updates to a single ref are strictly ordered, but a client reading several branches cannot assume they reflect one moment in time. OpenAI gives an example where two clients cloning at once could see two branches at different versions. Its view is that users and agents in practice care about the order of updates to a single ref.
Advertising fewer refs
A conventional Git server shows the client every branch so the client can leave out objects the server already has. OpenAI says that with millions of branches, this list alone can exceed 100 MiB.
By default, Pando advertises only a designated trunk branch when a client pushes a new feature branch. That keeps the advertisement a constant size and makes the pack reusable by anyone who already has the trunk history. The tradeoff is that repeated pushes to one branch, or stacked feature branches, resend more data. In its monorepo, OpenAI reports a median packfile under 20 KiB and a 99th percentile under 3 MiB.
Reads: reusing packs
On fetch, Pando maps the client's haves and wants to ref versions and selects stored packs that cover what is missing. It returns links to those packs using the packfile-uri feature of the Git protocol, and an empty pack inline. The client downloads the packs through Express, which caches them regionally. OpenAI says it contributed several improvements to packfile-uri upstream.
Since servers mainly negotiate and select packs, OpenAI says Pando servers can run on commodity hardware.
Compaction
Sending a link per push would mean tens of thousands of packfiles per day for a client catching up on trunk, according to OpenAI. So background workers combine packs into larger covers at geometrically increasing levels, similar to compaction in log-structured merge-trees. The post says the monorepo currently uses up to L4 covers.
These covers improve compression and act like a skip list over ref versions, so pack selection takes logarithmic time. Unlike many Git servers, Pando keeps packs at every level rather than discarding them.
How OpenAI built and rolled it out
OpenAI says it built Pando with Codex from kick-off to production in 10 weeks. In its account, one engineer designed the core, teams of agents implemented it and a handful of engineers deployed it. It chose Rust, wrote a conformance test suite against standard Git behavior, and used deterministic simulation testing to find race conditions.
The rollout started with Pando acting as a read- and write-through proxy in front of the existing system. That allowed both to stay in sync, so traffic could move without downtime. OpenAI used a wrapper around the Git CLI to migrate clients in phases, and says it moved hundreds of integrations that relied on older APIs, webhooks and repository downloads.
Contributions back to Git
OpenAI says running Pando on the standard Git client exposed bugs in concurrent downloads, cleanup after interrupted transfers and resuming completed downloads. It fixed those paths and contributed the work upstream. Separately, it added validations when accepting an existing pack for a fetch, and added tracing for packfile-uri downloads and pack-generation byte counts.
It also added "explicit haves," which let a server advertise a branch tip separately from the history a pushing client may leave out. The post says several improvements are already in upstream Git, with others in its public repository and patch tracker.
What this means for businesses and developers
Most teams do not run a monorepo at this scale, but several points carry over:
- Measure before replacing. OpenAI posed the question of whether Git itself or its repository serving was the limit. Check whether your slow pushes and fetches come from the protocol or from your hosting setup.
- Watch for agent-driven load. The post links the strain to more parallel branches, pushes and CI fetches. If you adopt coding agents, track push rates and fetch fan-out from CI jobs.
- Know your consistency needs. Pando trades a global point-in-time view for per-branch ordering. Ask whether any of your tooling assumes that all refs are read at one moment.
- Migrate behind a proxy. OpenAI's proxy-first rollout let old and new systems run together. A similar staged approach lowers risk for any source control change.
- Test against standard Git. A conformance suite and simulation tests were central to OpenAI's validation. Any custom Git service benefits from tests that compare it with stock Git behavior.
Final thoughts
Pando is a reported example of keeping Git's client and protocol while redesigning the server around independent branches and reusable packs. The results come from OpenAI's own environment, and the post does not include outside measurements.
OpenAI says it is exploring ways to share the technology with its users and will keep working with the Git community. For now, the clearest takeaway for other teams is the way it framed the problem: find out where the bottleneck is before deciding how much to change.
