OpenAI has replaced the backend behind its primary monorepo with Pando, a custom-built Git-compatible storage system designed for a world where thousands of AI coding agents push, merge and fetch code around the clock. According to a white paper the company published on November 2, 2026, titled "Scaling Git at OpenAI: Building agentic-scale source control while investing in the Git ecosystem," the legacy system had started to fail as commit volume climbed toward a projected 2,442% increase by Q4 2026 compared with Q1 2024. Pando, the paper reports, cut median push latency by nearly 5x, lifted merge infrastructure reliability to 99.99%, and now serves nearly a petabyte of Git data per day.
The more interesting story is how OpenAI got there. Rather than adding servers to a design that could not scale, the team discarded two assumptions that most engineers treat as untouchable in a version control system. What follows is an explanation of why the old setup broke, what Pando does differently, and what the approach may mean for anyone running infrastructure that AI agents will soon hammer.
When agents never go home
Git was created more than two decades ago to help Linux kernel developers exchange patches over email. That model fit human teams well: engineers work in roughly linear fashion, during working hours, and take breaks. Codex, OpenAI's code-generation model, changed the physics of the workload. Swarms of autonomous agents run in parallel, continuously, with no business hours. They create branches, push rapid-fire commits, merge constantly, and trigger non-stop clone and fetch traffic from CI/CD pipelines and research experiments.
A chart in the paper shows quarterly commits landed on master in OpenAI's monorepo growing along an exponential curve from a Q1 2024 baseline, reaching the 2,442% figure by Q4 2026. The existing infrastructure buckled: fetches slowed, pushes stalled, and merges failed. A second chart tracking daily merge infrastructure success over 37 weekdays shows the rate dipping below 90% several times, which halted development workflows across the company.
Why the standard playbooks did not work
Before building something new, OpenAI modeled two conventional ways to run a distributed Git backend. Both failed under high concurrency, and for instructive reasons.

▲ Three-Phase Commit and Write-Ahead Log bottlenecks
Three-Phase Commit: the committee
The first option was Three-Phase Commit, or 3PC, a consensus protocol in which incoming packfiles (Git's compressed bundles of objects) are copied to every replica in parallel, but each update can only be committed once a majority of replicas agree in lockstep. The effect resembles a corporate committee that must review and stamp a single document before anything is final, while every later request waits in the hallway. Writes become strictly serial. Worse, 3PC cannot scale horizontally: adding replicas increases the number of nodes that must reach consensus, which lengthens the coordination rounds and makes latency worse rather than better.
Write-Ahead Log: the single pen
The second option was a shared Write-Ahead Log (WAL) backed by central blob storage. Here, packfiles upload in parallel to shared storage, and reference updates are recorded in a central manifest using an atomic compare-and-swap (CAS) operation, which succeeds only if nobody else changed the manifest first. The picture is of many fast writers who all share one pen to sign one ledger. If another agent commits milliseconds earlier, the CAS fails, and the writer must fetch the latest manifest, re-validate its update, and retry. Under agentic load, contention on the manifest produces retry storms and queuing delays. The WAL design does not remove the bottleneck; it relocates it.
A simulation of the gap
OpenAI published an interactive simulation that compares the three designs under 1,000 concurrent writers. The paper frames these as teaching models, not production benchmarks, but the gap is striking:
| Architecture | Time to finish 1,000 writers | Mean push-to-fetch latency |
|---|---|---|
| Three-phase commit | 56.52 s | 4.63 s |
| Object-store WAL | 96.26 s | 6.38 s |
| Pando | 7.71 s | 0.47 s |
Two assumptions Pando throws away
Having concluded that standard distributed-systems patterns were insufficient, the team questioned two foundations of Git backend design.
Assumption one: repository-wide consistency
Traditional Git servers guarantee that every fetch sees a globally unified, point-in-time snapshot across all references. Pando drops that guarantee in favor of causal consistency, with strict serializability applied only to individual references. In plain terms, updates to any single branch are ordered into one clean timeline, but the system no longer coordinates ordering across unrelated branches.
OpenAI argues this mirrors how engineers actually work. Someone pushing iterative changes to a UI feature branch does not care about the microsecond ordering of 50 unrelated database migration branches. They care that their branch contains their commits and that the trunk they will merge into is accurate. The paper calls this "localized truth," as opposed to an expensive, globally coordinated truth. Two developers can simultaneously see branch alpha at v1 and beta at v2, and alpha at v2 and beta at v1, without any loss of integrity. Push conflicts occur only when two clients push to the exact same reference at the same time, and because there is no global push lock, unrelated branch writes proceed fully in parallel.
Dropping global consistency sounds alarming to most experienced developers, and the paper's position is that the alarm is misplaced because real workflows do not depend on cross-branch snapshot ordering.
Assumption two: a bespoke packfile for every client
In a standard Git push, the server behaves like a poker player showing its entire hand: it advertises every branch and its current commit, a list that can exceed 100 MiB when a server has millions of branches. The client inspects the list, computes exactly which objects the server lacks, and builds a tightly compressed packfile. This design dates from an era when bandwidth was scarce, so it spends CPU and disk I/O to minimize bytes. On the server, dynamically repacking or computing custom deltas per client burns enormous resources, and because every packfile is unique to one client's momentary state, nothing can be cached or reused. Every fetch starts from scratch.
Pando plays its cards close. It advertises only a designated trunk branch, such as main, and clients compute their upload packfile relative to that trunk baseline. The tradeoff is that a client pushing repeated commits to its own branch may resend intermediate commits that are not yet in trunk, which costs some extra upload bandwidth. OpenAI's production data says the cost is small: the median push packfile in the monorepo is under 20 KB and the 99th percentile is under 3 MB. In exchange, the server never repacks.
The write path and the read path
Because packfiles are built against a shared baseline rather than a unique client state, they are no longer single-use artifacts. Pando's write path receives the roughly 20 KB file, writes it to immutable blob storage, updates metadata, and finishes. No repack computation occurs, which turns push ingestion into an O(1) metadata write, meaning its cost does not grow with repository size or load.
Reads work differently too. When a client fetches a branch, Pando returns a list of packfile URLs rather than computing a delta bundle. That traffic flows through Express, an internal regional edge-caching layer deployed across OpenAI's operating regions that caches both blob storage and metadata. OpenAI reports cache hit rates above 99%, which lets standard cloud virtual machines saturate 10 Gbps network links during clones and fetches with almost no central server CPU.

▲ Pando's tiered compaction from L0 to L4
Compaction: keeping receipts from piling up
Storing every push as its own small immutable file invites "tiny file bloat." An engineer returning from two weeks away could face tens of thousands of separate packfile downloads, with 50,000 used as the illustrative figure. Pando addresses this with a background compaction scheme modeled on LSM trees, a storage structure common in databases that merges small writes into larger sorted files over time.
A bookkeeping metaphor captures how the tiers work:
- Level 0 (L0): each 20 KB push is a loose receipt on the accountant's desk
- Level 1 (L1): a background service staples batches of receipts into weekly summaries
- Level 2 (L2): weekly summaries roll into monthly folders
- Level 4 (L4): everything eventually lands in a yearly ledger
A client catching up needs only a few recent L0 receipts, a couple of L2 folders, and the L4 ledger, not thousands of loose files. Metadata reads therefore scale logarithmically, written as O(log delta): the server consults a small number of structured indexes rather than scanning 50,000 files, so retrieval time barely rises as data volume grows. Unlike traditional Git servers that garbage-collect old packfiles after a repack, Pando retains packfiles at every tier from L0 to L4, so it can serve any fetch at the granularity needed without pausing for on-demand recompression. Compaction runs asynchronously, so it adds no delay to writes.
Built by agents, proven with math, deployed without downtime
The paper describes an unusual build process. Pando's core architecture was designed by a single engineer, implemented by teams of agents using Codex, and shipped to production in 10 weeks. It was written from scratch in Rust with no legacy dependencies, and agent changes were benchmarked against standard Git behavior using custom conformance test suites.
For correctness, OpenAI used GPT-6 Astra agents to formalize a "theory of Pando" in Lean and TLA+, specification languages that model a system as a mathematical state machine with invariants that must hold in every state. Model checkers then simulated sequences of events, latency variations, concurrent pushes and server failures to prove whether the invariants held. Alongside the proofs, agents using Daybreak-capable models red-teamed the system continuously with deterministic simulation testing harnesses to surface race conditions before launch. Having AI models produce and check formal proofs for a distributed system appears to be a meaningful step beyond generating syntactically correct code.
The cutover itself used a read- and write-through proxy cache in front of both backends:
- On a push, the proxy wrote the data to both the legacy backend and Pando.
- On a fetch, the proxy checked Pando first and served from it on a hit.
- On a miss, the proxy fetched from the legacy backend, served the developer, and backfilled Pando asynchronously.
Developers used Codex automated skills to repoint their local environments and services to the proxy without hand-editing configuration. The migration happened with zero downtime across thousands of active engineers while commit rates were up roughly 2,400%, a feat comparable to replacing a skyscraper's foundation while crews add 2,000 floors a day. Seasoned architects may recognize the pattern under names like Strangler Fig.
Production results
| Metric | Result reported by OpenAI |
|---|---|
| Median push latency | Nearly 5x lower, about an 80% reduction |
| Merge infrastructure success | 99.99% after cutover, versus dips below 90% before |
| Daily Git data served | Nearly 1 petabyte |
| Peak hour | Over 57 TB of packs, over 99% from local disk cache |
| Server compute | A modest handful of CPU cores |
Giving fixes back to Git
Pando keeps strict wire compatibility with the open Git protocol rather than locking developers into proprietary tooling. Running at this scale exposed subtle concurrency bugs in standard Git clients during simultaneous downloads and interrupted-transfer cleanup, edge cases that human-paced teams had seemingly never hit. OpenAI patched them and contributed the fixes upstream. It also upstreamed a protocol feature called "explicit haves," which lets servers advertise tip commit references separately from packfiles so clients can push and fetch against trunk history, including force-with-lease checks, without re-downloading full trees.
What this means and what to do
The paper closes by pointing toward environments where large numbers of agents collaborate directly on shared repositories. In that framing, source control stops being an archive of human edits and becomes something closer to a real-time nervous system in which agents invent, test, merge and evolve software continuously. Whether that future arrives as described is a forecast, but the engineering lessons stand on their own:
- Do not design for human work patterns. Agent traffic is parallel, constant and bursty.
- Avoid synchronous multi-node consensus for high-frequency writes; adding nodes makes it slower.
- Treat a single CAS-protected manifest as a choke point under heavy concurrency.
- Ask whether clients truly need global consistency or only per-entity ordering.
- Anchor client delta computation to a static shared baseline, and accept a few extra kilobytes if it turns server computation into cacheable immutable storage.
- Use asynchronous tiered compaction and keep every tier instead of destructive garbage collection.
- Pair formal methods such as Lean and TLA+ with AI reasoning models before shipping distributed systems.
- Use a read- and write-through proxy to migrate critical infrastructure without downtime.
For teams that run Git servers, CI systems or any shared store that coding agents will soon hit at machine speed, the practical first step is to find the part of the stack that assumes one human at a time, because that is where the load will break first.


