TL;DR
OpenAI says its Git backend struggled as coding agents multiplied the number of branches, pushes and fetches hitting one monorepo.
Pando keeps the Git workflow but lets unrelated branches update independently. It also reuses stored Git data rather than building a fresh download for every client.
Pando doesn’t promise a single point-in-time view of all branches. That matters for tools that need a consistent repository-wide snapshot.

OpenAI says the service handling its monorepo, a single repository holding code for multiple projects, had a reliability problem. Fetches and pushes slowed. Some merges failed. At times, reliability fell below 90%.
Codex let an engineer work on several changes in parallel, each with its own branch, pushes and automated tests. That meant more systems asking the same repository for code, sometimes at the same time.
On November 2, OpenAI published the engineering details of Pando, the new backend now serving its monorepo. The company reports nearly 80% lower median push latency after switching, and says Pando delivers almost a petabyte of Git data daily. Those are OpenAI’s measurements for its own workload, not independent benchmarks.
Pando lets unrelated branches update independently, rather than requiring one update order across the whole repository.
Why unrelated branches can end up waiting
Picture one developer using three coding agents. One is updating a search feature. Another is fixing a payment form. The third is writing tests. Each agent creates commits on a separate branch, pushes them and asks continuous integration (CI) to test the result. CI then fetches the code, possibly from several machines.
The work on those branches might be completely unrelated. But a backend that orders every branch update through one shared coordination point can make them wait anyway. A faster network or a bigger machine won’t remove a queue that exists because every writer must take a turn.
Git is a protocol and a way of representing code history. How a hosted service stores that history, replicates it and handles competing writes is a separate engineering choice.
I’ve written about a related failure in Coordination Is an Architecture Problem Disguised as a Prompt Problem: two agents with conflicting views of who owns a task. That was about the shared state agents use to decide what to do. Pando is a narrower case. The agents can agree on their tasks and still run into a backend that makes independent code changes wait for one another.
Pando changed two things
First, Pando coordinates updates per branch, rather than requiring one ordered snapshot of every branch at once. A push to a search-feature branch can proceed while another client updates a payment-feature branch. If two clients try to move the same branch, they still have to resolve that conflict. The system hasn’t removed the need to coordinate. It’s reduced the scope of the coordination.
There is a technical name for part of this choice: causal consistency. When someone fetches a branch, Pando gives them the history that branch depends on. But if they fetch several branches while changes are arriving, those branches may reflect different moments in time. The system doesn’t promise one global snapshot for that read.
That sounds odd until you ask what the reader is actually doing. If a developer fetches one feature branch to review its commits, the history leading to that branch matters. Whether an unrelated branch changed a fraction of a second earlier may not. And if two features eventually need to work together, the merge and the tests still have to establish that they do.
Second, Pando avoids rebuilding a custom download every time someone fetches code. Git stores file contents and history as objects. Each object has an ID calculated from its type and contents. It can bundle those objects into compressed files called packfiles. Conventional servers often calculate which objects each client is missing, then generate a packfile for that particular fetch.
Pando saves incoming packfiles and reuses them. A client may receive some objects it already has, but the service can send the same stored bytes to many clients from caches instead of repeatedly doing expensive pack-generation work. Pando uses Git’s packfile-URI feature to send clients links to the stored packs they need. The Git documentation describes this feature, which requires protocol version 2. Pando still combines and recompresses packs in the background instead of doing that work separately for every fetch.
To make those packs reusable, Pando normally advertises only the trunk branch, the main development branch, as shared history when a client pushes a feature branch. Later pushes resend objects outside that trunk history, even if the server already has them. OpenAI reports that the median incoming packfile under this approach was less than 20 KiB and its 99th percentile was under 3 MiB. For its workload, the extra client bandwidth was worth accepting because another client with the trunk history could reuse the pack. That’s OpenAI’s observed tradeoff, not a universal rule.
Testing and migrating the new backend
OpenAI says Pando went from kickoff to production in ten weeks, with coding agents helping implement it. Engineers tested it against standard Git behavior, ran repeatable simulations to catch timing-dependent bugs and used formal models to check the design. Keeping familiar Git commands didn’t remove the need to test what happened when clients pushed and fetched at the same time.
The migration is almost as interesting as the design. OpenAI says it first ran Pando as a proxy in front of its old service, keeping both in sync while traffic moved over. The team then migrated hundreds of integrations that depended on earlier APIs, webhooks and downloads. A clever storage design doesn’t help much if the tools around it stop working during the switch.
The rollout included client changes too. OpenAI says it shipped its own Git build to developer machines and the ChatGPT desktop app, then used a wrapper around Git commands to move clients over in phases. The workflow stayed familiar, but the migration involved more than replacing the server.
On November 4, Axios reported that OpenAI will acquire Pierre Computer, whose technology is already used in Codex. OpenAI told Axios it plans to integrate Pierre’s Code Storage more deeply. OpenAI separately says it’s exploring ways to share Pando’s technology with users, but its engineering post doesn’t announce a generally available service.
For teams watching these announcements, the question is less dramatic than whether Git is suddenly obsolete. OpenAI kept Git. It replaced the part underneath it that was making a particular workload expensive.
What I’d measure before changing anything
Teams with far less traffic than OpenAI may not need Pando. I’d start by looking at the delays already visible in the normal development process. When an agent finishes a change, how long does it wait for a push? How often do CI machines fetch the same large history? Are merges failing because of conflicting code, or because the service can’t keep up? Which operations still have to happen one at a time?
The answers matter because they point to different fixes. If most of the time is spent waiting for tests, faster pushes won’t change much. If the same Git history is repeatedly repacked and downloaded, caching or packfile reuse might help. If pushes to unrelated branches are waiting to update one shared record, the coordination design deserves engineering attention. If the real problem is conflicting edits to the same branch, letting unrelated branches move independently won’t solve it.
Before adopting Pando’s weaker cross-branch consistency, I’d identify every tool that needs a single snapshot across branches. A release system, for example, should record the exact commit IDs it will build and test. That makes the selected versions explicit, but it doesn’t prove they were all current at the same moment. If the release process requires that guarantee, it needs coordination elsewhere before giving up the repository-wide snapshot.
There’s a useful limit to what OpenAI’s numbers establish. They show a successful migration for one unusually large monorepo, using a backend tuned to OpenAI’s traffic. They don’t show that every Git service will slow down in the same way, or that every team should relax the same guarantees.
If more coding agents are making your work feel faster but your builds and code review still feel slower, follow the actual queue. In this case, the engineers found it underneath a familiar Git push.
Resources
OpenAI Engineering, Scaling Git at OpenAI (November 2, 2026). Primary description of Pando’s architecture, deployment and company-reported performance.
Git documentation, packfile-uri. Protocol reference for fetching packfiles by URL.
Axios, OpenAI targets Microsoft’s GitHub with deal (November 4, 2026). Acquisition reporting, separate from the Pando engineering claims.

