OpenAI Replaces Git Backend With Pando as Codex Agents Overwhelm Its Monorepo

TL;DR

OpenAI has moved its entire monorepo onto Pando, a Git-compatible backend it built after Codex agents pushed so many branches at once that fetches slowed, merges failed, and reliability at times fell below 90%. Pando keeps the standard Git client and protocol, cuts median push latency by nearly 80%, and now serves close to a petabyte of Git data a day. One engineer designed the core, teams of Codex agents implemented it, and it hit production in 10 weeks.

What broke first

Codex changed the shape of work at OpenAI: an engineer now has several changes ready for CI at the same time, and every push sends dev environments, research jobs, and CI fetching the same commits. Through late 2025 the systems serving the monorepo fell behind, with slow fetches, failed merges, and reliability sometimes under 90%. The team had to decide whether Git itself had hit a limit or just the way they were serving it. They picked the serving layer.

Anthropic landed on the same answer three weeks earlier, after its merges per day grew more than tenfold and it rebuilt its own source control. Agents push far more branches in parallel than human teams ever did, and the assumptions baked into most Git servers predate that traffic pattern by two decades.

Two tradeoffs carry the design

Pando gets its speed by refusing two things most Git servers treat as requirements.

Repository-wide consistency is the first to go. A conventional server gives every client one point-in-time view of all refs, which forces writes to unrelated branches to queue behind each other. Pando serializes updates per branch and stops there. Read branches foo and bar in one clone and you can catch foo at version 1 and bar at version 2, while another client sees the reverse. Picture a group chat where each thread keeps strict order inside itself, but no two threads promise to be synced to the same minute. OpenAI says that in practice both humans and agents depend only on the order of updates to the branch they are on.

Custom packfiles go next. A normal server computes a fresh pack for each client based on what that client already has, which costs CPU and disk and defeats caching. Pando stores every pushed packfile as an immutable blob and serves those same bytes to everyone; a client occasionally re-downloads an object it already owns, and that is the whole price. Instead of mastering a custom mixtape per listener, the server hands out the same boxed set and lets caches multiply it.

What a push and a fetch actually do

On git push, Pando validates the incoming packfile in a single pass while streaming it to blob storage, never unpacking it into a local repository. A multi-key transaction records a ref version, the new branch tip plus the pack it depends on, behind an atomic compare-and-swap. Pushes to unrelated branches never contend. On git fetch, Pando maps the client's haves and wants onto stored packs and returns download links through the packfile-uri extension of the Git wire protocol, with an empty pack inline. A delivery service called Express caches packs per region; OpenAI reports hit rates above 99%.

One more detail keeps this cheap. By default Pando advertises only the trunk branch to pushing clients, because with millions of branches the ref advertisement alone can exceed 100 MiB. The cost is redundant bytes on stacked branches, and it is small: a median packfile under 20 KiB, a 99th percentile under 3 MiB. Background compaction merges packs across levels, LSM-tree style, up to L4 in production today.

The numbers OpenAI published

These are OpenAI's own figures about its own system, from the engineering post dated November 2:

• Median push latency down nearly 80%, about 5x, on the same workflows and the standard Git client.
• Nearly a petabyte of Git data delivered per day, on what the post calls a handful of CPU cores.
• More than 57 TB of Git packs served in a single hour, with over 99% of those bytes from local disk cache.
• Clones and fetches saturating 10 Gbps network links on standard cloud VMs.

Built by agents, checked with proofs

The build is its own AI story. Kickoff to production took 10 weeks: a single engineer designed the core, teams of Codex agents implemented it, and a handful of engineers deployed it. It has served production traffic since April. The code is Rust, greenfield, with no legacy dependencies, a conformance suite so agents could test their changes against real Git behavior, and deterministic simulation testing for race conditions in negotiation and pack planning.

Agents also wrote Lean and TLA+ specifications of a "theory of Pando", which OpenAI says found and fixed implementation bugs and proved properties of the system, with some continuous sessions running for hundreds of hours. Other agents red-team Git and Pando around the clock.

Git's first commit is dated April 7, 2005, days after Linus Torvalds started writing it, and it describes itself as "the information manager from hell". Pando took ten weeks, with agents doing most of the typing.

Migration ran through a read- and write-through proxy in front of the old system, keeping both in sync while workloads moved one at a time, with no downtime. OpenAI shipped its public Git build to developer machines and inside the ChatGPT desktop app, migrated hundreds of integrations off legacy APIs and webhooks, and wrote Codex skills so a developer could ask Codex to move their own environment over. The migration tool for the system agents overloaded was, of course, agents.

What you can touch today

Pando itself is not public. OpenAI says it is "exploring ways to share the technology", which reads as intent, not a release. Two artifacts exist now:

• openai/git, a public Git fork with the client-side work: parallel download and indexing of independent packs, an "explicit haves" mechanism so a server can advertise a branch tip separately from the history a pushing client may omit, and tracing for packfile-uri transfers.
• Upstream Git patches, several already merged, with the rest tracked in a public patch tracker.

If you run agent fleets against a shared repo, the lesson to steal is unglamorous. The source-control server becomes a contention point that scales with agent count, and pack caching, small ref advertisements, and proxy-first cutover are the moves that carried a monorepo this size.

Caveats

• Every number in this post is OpenAI reporting on its own system. Nobody outside has audited the latency or throughput figures, and the post publishes no absolute rates, no pushes per second and no measured concurrent-client count, only a qualitative claim of "many thousands of clients". Commenters on Hacker News, where the post drew 270 points and 180 comments, flagged that gap quickly.
• Pando is unreleased, so the design is copyable only in the sense that a good blog post is copyable.
• Causal consistency changes behavior for tooling that assumes a repo-wide snapshot. Some CI triggers and mirroring jobs do.
• The 10-week build with one designer is also a self-report, published by the company that sells Codex.

Key Takeaways

• Agent concurrency, not repository size, is what broke OpenAI's source control; reliability fell below 90% before the rebuild, and Anthropic reported the same wall in October. Watch your Git server as your agent count grows.
• Pando's speed comes from dropping two assumed requirements: repo-wide point-in-time consistency, replaced by per-branch causal consistency, and per-client packfiles, replaced by immutable stored packs served as-is to every reader.
• Published results: median push latency down nearly 80%, nearly a petabyte of Git data a day, 57 TB in one hour with over 99% of bytes from cache, fetches saturating 10 Gbps links.
• The build itself is the AI story: one designer, Codex agent teams as implementation labor, Rust plus Lean and TLA+ proofs and deterministic simulation testing, production in 10 weeks.
• Usable today: the openai/git fork and the upstream Git patches. Pando itself is not released.

Sources: OpenAI Engineering, openai/git on GitHub, OpenAI's public Git patch tracker, Hacker News discussion, Anthropic Engineering, Tao Media