Has AI Outgrown Git? OpenAI's Pando Cuts Push Latency Nearly 5x

OpenAI rebuilt its Git backend as Codex agents flooded its monorepo. Pando cut median push latency nearly 80%, and your git commands don't change. Here's how.

TheTechLane cover on a midnight-indigo blueprint: a glowing branch graph of mint and coral Git lanes flows into a large TL logo hub, beside the headline Has AI Outgrown Git? and the line OpenAI's Pando cuts push waits nearly 5x

OpenAI has rebuilt the server side of Git after its monorepo struggled to keep up with Codex-driven work, and its new backend, Pando, cut median push latency by nearly 80%. Engineers and agents still type the same git push and git fetch. Only the machine on the other end changed.

Here's what you need to know:

  • OpenAI detailed Pando on November 2, 2026. It now powers all development in OpenAI's monorepo and has served production traffic since April 2026.

  • Median push latency fell nearly 5x (about 80%), and Pando delivers nearly a petabyte of Git data a day.

  • It's written in Rust, went from kick-off to production in 10 weeks, and was designed by one engineer while teams of Codex agents implemented it.

  • It stays fully Git-compatible, unlike Anthropic's Scion, which replaced Git outright.

  • Pando is not open source. OpenAI says it's "exploring ways" to share the technology.

UML sequence diagram of OpenAI's Pando Git backend: a writer agent runs git push on a feature branch, Pando advertises only trunk as the base, receives a small packfile, validates and streams it to the blob store without unpacking, records a ref version and compare-and-swaps the branch pointer in the metadata store, then accepts the push, with only pushes to the same branch conflicting; a CI reader then sends git fetch haves and wants, Pando maps them to ref versions, returns an empty inline pack plus packfile URIs, and the reader downloads the stored packs from the Express regional cache with over 99% hit rate

How Pando handles a push and a fetch

What Happened

In OpenAI's engineering post, "Scaling Git at OpenAI", Aaron Friel, Taylor Blau and Ted Nyman explain that Codex changed "the scale and pace of development," meaning more branches, more pushes, more merges and more fetches from dev environments, research jobs and CI. Starting around the end of last year, the old setup struggled: slow fetches and pushes, failed merges, and reliability "at times falling below 90%."

The volume is wild. OpenAI's commit chart shows commits landed on master up 1,378% in Q3 2026 versus Q1 2024, with a Q4 estimate of +2,442%, according to MarkTechPost's breakdown of the Pando post.

The team asked whether it had hit "a limit of Git itself, or of the way we served our monorepo?" Its answer was the server. So Pando drops two things most Git servers treat as requirements:

  • Repository-wide consistency. Pando handles each branch on its own (OpenAI calls it causal consistency). Pushes to unrelated branches don't wait on each other. Clients only conflict when they push to the same branch at the same moment.

  • A fresh packfile for every client. Pando stores each pushed packfile as an immutable blob and reuses it for later fetches, instead of computing a custom pack per reader.

On a push, Pando validates the packfile while streaming it to blob storage, then records a "ref version" in a metadata store with a constant number of reads and writes. On a fetch, it picks the stored packs the client needs and hands back download links through Git's packfile-uri feature. A cache service called Express serves those packs from regional caches with hit rates above 99%. OpenAI says standard cloud VMs can saturate 10 Gbps links on clones and fetches, and Pando once served more than 57 TB of packs in a single hour.

To stop clients downloading tens of thousands of tiny packs a day, background workers compact them into bigger "covers," much like an LSM-tree database. The monorepo uses covers up to L4.

Why It Matters

Git servers weren't built for thousands of agents pushing at once. As The New Stack's report on Pando puts it, with development speeding up, "Git itself is becoming a bottleneck," and OpenAI's problems are "similar to what many other enterprises and Git forges like GitHub are now seeing."

There are now two answers from the two biggest AI labs. In October, Anthropic described Scion, an in-house system that replaced Git after daily merges jumped from around 2,500 in May to over 30,000 in September. Scion moves commits and merges to the server and uses its own client. OpenAI went the other way: keep the Git client and protocol, rebuild only the backend.

That choice matters to everyone else. A Git-compatible design means existing tools, CI and muscle memory keep working, and OpenAI says several of its client fixes are already in upstream Git, so improvements can reach you even though Pando itself stays private.

It's also a showcase for agent-built infrastructure. OpenAI says agents using GPT-6 Astra wrote Lean and TLA+ to formalize a "theory of Pando" and find bugs, backed by a Git conformance suite and deterministic simulation tests. We saw a similar pattern when AI agents built tsrs, a Rust port of TypeScript.

What It Means for Developers

Flowchart comparing how three Git server designs order ref updates when 1,000 agents push to 1,000 different branches: three-phase commit has a quorum of full replicas vote on each ref update, so replica disks saturate and write latency grows under load; a shared write-ahead log makes every push update one shared manifest via compare-and-swap, so replicas fall behind reading the log and read latency grows; Pando gives each branch its own ref pointer and ref versions, so unrelated pushes run in parallel and cached packs serve readers

Why unrelated pushes stop waiting on Pando

You can't run Pando. But if agents are multiplying your pushes, the post is a free design review:

  • Measure before you blame Git. OpenAI's bottleneck was how the server ordered writes and built packs, not the Git client.

  • Watch push contention. If one shared lock or manifest orders every branch update, unrelated agent pushes will queue behind each other.

  • Cache the bytes, not the work. Reusable packs plus regional caches let many CI jobs fetch the same commit with little server CPU.

  • Expect cross-branch reads to be eventually consistent. Pando trades a single point-in-time view of all branches for parallel writes. Tools that read several branches together shouldn't assume one snapshot.

  • Follow upstream Git. OpenAI is contributing packfile-uri fixes, download tracing and "explicit haves" through its public patch tracker. Newer Git clients may fetch faster against big repos.

  • Plan for agent volume. If you run coding agents that open PRs, like DeepSeek's open-source Super-Agent, your source control and CI will feel it first.

What's Next

OpenAI says it's exploring other uses for Pando, "including workloads where large numbers of agents need to collaborate on a shared Git repository," and ways to share the technology with its users. It hasn't said whether that means an open-source release, a hosted product, or a Codex feature.

A few caveats are worth watching. Every performance figure is self-reported, and the 1,000-writer simulation in the post is labelled a teaching model, not a production benchmark. Repeat or stacked branch pushes also resend everything outside trunk, though OpenAI says the median pack was under 20 KiB and the 99th percentile under 3 MiB.

The bigger question: will GitHub and GitLab adopt these ideas before more teams hit the same wall?

FAQ

Do OpenAI engineers have to use a new Git client?

No. Pando keeps the standard Git protocol and client, so git push and git fetch work as before. OpenAI does ship its own Git build to developer machines and the ChatGPT desktop app to get the best performance.

Can I use Pando in my own company?

Not today. Pando isn't open source, and OpenAI only says it's exploring ways to share the technology. Some of its Git client improvements are already upstream, and others are in its public patch tracker.

How is Pando different from Anthropic's Scion?

Pando keeps Git and rebuilds only the server backend. Scion replaces Git with its own client, server-side commits and merges, and its own code review and CI tools. Neither company plans a public release right now.

Sources

Follow TheTechLane

Keep learning AI, development, and modern developer technologies with TheTechLane.

Learn • Build • Share

Follow @thetechlanehq for more developer guides, tutorials, and practical technology content.