Codex Broke OpenAI's Git. So OpenAI Rebuilt the Backend in 10 Weeks.

OpenAI's monorepo started buckling late last year. Not from too much code — from too many agents.

Codex lets a single engineer keep several changes ready for CI at once, and every push fans out into multiple CI jobs fetching the same commit. Branches, pushes, merges and clones compounded until source-control reliability at times dropped below 90%.

The fix is Pando, a new Git backend that now powers all development in OpenAI's monorepo. Engineers and agents still run plain git push and git fetch. The numbers: median push latency down nearly 80% (close to 5x), nearly a petabyte of Git data served per day, a peak of more than 57TB of packs in a single hour, with over 99% of those bytes served from local disk cache.

All of that, OpenAI says, on "a handful of CPU cores."

What most people are getting wrong

The hot take is "OpenAI is coming for GitHub." Not yet.

Pando is a storage-and-delivery layer, not a hosting platform. Code review, change requests and automation APIs live in separate internal tools. Greg Brockman's framing was measured: Pando scales to very large monorepos, OpenAI is considering offering it to others, and interested parties can email him. The official post says only that OpenAI is "exploring ways to share the technology."

The real story: agent-scale concurrency has pushed Git's two-decade-old infrastructure assumptions past their limit. Human teams rarely push to a thousand branches at once. Agents do it every day.

What actually changed

Pando keeps the Git protocol and client intact but drops two things most Git servers treat as non-negotiable.

Repository-wide consistency. Conventional servers put every ref update into one global order, so one agent's push to its branch waits on another agent's push to an unrelated one. Pando uses causal consistency: each ref is serializable on its own, unrelated branches write in parallel. The only contended key is the ref pointer, guarded by a CAS-like atomic operation. Push metadata cost is O(1).

The trade-off: a reader looking at several branches may see them at different points in time. OpenAI's bet is that users and agents care about ordering within a branch, not across the repo.

A bespoke packfile for every client. Traditional servers compute the have/want difference and compress a fresh pack per fetch — CPU- and I/O-heavy, and nearly uncacheable. Pando reuses the packfiles it received on push. Incoming packs are validated while streaming into blob storage, never unpacked. On fetch, Pando picks the stored packs the client needs and returns links via packfile-uri, an under-used Git protocol feature; a delivery service called Express serves them from regional caches. Clients may download a few objects they already have; the server barely computes anything.

Fetch planning costs O(log Δ) metadata reads. Express routes via consistent hashing with cache hit rates above 99%. On standard cloud VMs, clones and fetches saturate 10 Gbps links.

Details worth noting:

• On push, Pando advertises only the trunk branch. With millions of branches, a full ref advertisement alone can exceed 100 MiB.
• The cost is redundant objects on stacked branches — yet the median pack was under 20 KiB and P99 under 3 MiB.
• Background compaction borrows from LSM trees: L0 packs roll up into geometric covers, up to L4 in OpenAI's monorepo today. No level is garbage-collected; the covers double as a skip list over ref versions.

One designer, a team of agents, 10 weeks

Pando went from kickoff to production in 10 weeks, built with Codex. One engineer designed the core, teams of agents implemented it, a handful of engineers deployed it. It has served production traffic since April. It's written in Rust with no legacy dependencies.

Validation was agent-driven too: a Git conformance suite agents test against, deterministic simulation harnesses for race conditions, and agents using GPT-6 Astra to write Lean and TLA+ formalizing a "theory of Pando" — with continuous sessions running for hundreds of hours. Agents also red-team Git and Pando around the clock.

Migration was zero-downtime: Pando first ran as a read- and write-through proxy in front of the old system, then took workloads one at a time. Developers simply asked Codex to migrate their environments. Hundreds of integrations built on legacy APIs and webhooks moved with them.

Feeding Git upstream

OpenAI has contributed fixes back to Git: packfile-uri improvements, cleanup after interrupted pack downloads, concurrent-download edge cases, and tracing and byte counts for pack transfers. Its own Git build downloads and indexes packs in parallel and adds "explicit haves," letting --force-with-lease build a branch's pack against trunk alone. That build already ships to developer machines and inside the ChatGPT desktop app.

The engineering post is by Aaron Friel, Taylor Blau and Ted Nyman.

Why it matters

For a year, the agentic-coding conversation has been about how much code models can write. Pando is about the other half: whether infrastructure can absorb it.

Git isn't going anywhere. But the defaults — one global order, a freshly computed pack for every fetch — are breaking under agent-scale load. OpenAI just showed you can keep Git and still scale past them. It won't be the last company to hit that wall.