OpenAI Kept Git and Rebuilt Everything Behind It

OpenAI Kept Git and Rebuilt Everything Behind It

The important architectural point is not that Git was replaced, but that the compatibility boundary stayed intact while the scaling model changed underneath it. That matters for platform teams because developer tooling, IDE integrations, CI jobs, hooks and automation often depend more on stable Git semantics than on the storage implementation itself. OpenAI’s approach effectively treats Git as a protocol contract while redesigning concurrency, caching and packfile distribution as separate infrastructure concerns.

For enterprise engineering teams, the practical question is where their own bottleneck really sits: Git metadata operations, branch advertisement, packfile generation, object storage throughput, CI fan-out, or repeated clone/fetch behavior from ephemeral runners. Agent-heavy workflows amplify all of them at once. If every push triggers parallel validation, indexing, testing and research jobs, source control starts behaving less like a developer tool and more like a high-volume content distribution system.

The trade-off worth watching is consistency. Per-branch ordering is likely sufficient for most developer workflows, but adjacent systems may quietly assume a repository-wide point-in-time view: merge automation, policy enforcement, audit tooling, dependency graph generation, monorepo-wide analysis and compliance scans. Teams adopting similar designs need to identify which services can tolerate branch-local consistency and which still require stronger coordination.

A useful near-term response does not require building a custom backend. Measure clone amplification, cache-hit ratios, branch-count growth, queueing during concurrent pushes and the percentage of CI work that refetches identical objects. Those metrics will tell teams whether they need better runner-local caching, packfile reuse, branch-discovery changes, or a deeper separation of Git control-plane operations from bulk object delivery.




Coding agents keep finding the weak spots in infrastructure built for people. At OpenAI, that weak spot was the server behind its monorepo.

In a November 2 engineering post, OpenAI’s Aaron Friel, Taylor Blau, and Ted Nyman explained how Codex changed the load on the company’s source control. Each engineer now runs many tasks at once. That multiplied branches, pushes, and merges. It also multiplied fetches and clones from laptops, research jobs, and CI, since each push can kick off several jobs that fetch the same commit.

Starting around the end of 2025, the old setup couldn’t keep up. Fetches and pushes slowed down. Merges failed. At times, reliability dropped below 90%.

OpenAI’s answer was a new Git backend called Pando. It now handles all development in the monorepo. And the engineers and agents using it didn’t have to change a thing. They still run ordinary git push and git fetch commands against the same Git client.

The team first asked whether they had hit a limit in Git itself or in how they served it. The answer was the serving layer.

The biggest change is how Pando handles consistency. A conventional Git server treats the repository as one unit, so pushes to unrelated branches can end up waiting on each other. Pando coordinates each branch independently. Two agents pushing to different branches never contend. Updates to a single branch stay strictly ordered. OpenAI calls this causal consistency. The trade-off is that a client reading several branches can’t assume those reads reflect one point in time. OpenAI argues that people and agents care about the order of updates on a branch, not a global order.

Pando also changes what the server tells clients. A standard Git server advertises every branch it holds each time a client connects. With millions of branches, that list alone gets heavy. By default, Pando advertises only a designated trunk branch.

The third change is how Pando moves data. Incoming packfiles go straight into blob storage without being unpacked on the server. Metadata storage records the new branch versions. When a client fetches, Pando checks what history the client already has, picks the packfiles it needs, and points the client to a download location. A delivery service called Express serves those files from regional caches. Pando reuses existing packfiles instead of building a fresh one for every client. Background workers merge small packfiles into larger ones, much like compaction in a log-structured merge tree. Pando is written in Rust and runs on commodity hardware.

The results, as OpenAI reports them, are large. Median push latency dropped by about 80%, close to 5x faster. Pando sends nearly a petabyte of Git data to clients each day. In its peak hour, it served more than 57 TB of packfiles, with over 99% of those bytes coming from local disk cache. These are OpenAI-reported figures from its own environment.

The way OpenAI built Pando is part of the story. The company says Codex built it in about 10 weeks. One engineer designed the core architecture, teams of agents implemented it, and a small group handled deployment. Agents using GPT-6 Astra wrote Lean and TLA+ specifications to formalize a “theory of Pando,” which the team used to find and fix bugs. Agents also red-team Git and Pando around the clock.

The migration avoided a hard cutover. Pando first ran as a read-write proxy in front of the legacy system, and traffic moved over in stages with no downtime. It began serving production traffic in April. Developers then used Codex to move their environments, services, and integrations.

OpenAI isn’t alone here. GitHub said in October that it is separating Git storage from compute to absorb agent-driven commit growth. Anthropic built its own source control system, Scion, for its monorepo, and Cursor has introduced Origin, a code forge aimed at agents. OpenAI’s approach stands out because it stays compatible with Git. For platform teams, that means no retraining and no tooling changes for the people and agents on the other end. Some of its packfile-uri improvements are already merged upstream, and other changes are public. Pando itself remains internal, though OpenAI says it is exploring ways to share the technology.

Most organizations won’t build their own Git backend. The more useful lesson is where the pressure showed up. Agents didn’t break Git. They broke a service built on the assumption that people push code a few times a day. Self-hosted Git servers, CI runners, artifact stores, and anything that clones on every push were sized for that same rhythm.

DevOps teams running agents in parallel worktrees or CI should start tracking fetch latency, push latency, and failure rates now. Those numbers will show where the next bottleneck sits, ideally before it shows up as a stalled merge queue.

Original Post

Enjoyed this article? Sign up for our newsletter to receive regular insights and stay connected.

Leave a Reply