OpenAI’s Pando Git Backend Cuts Push Latency for Agent-Scale Development

OpenAI’s Pando backend is a bet that Git can support much faster development without requiring developers to abandon Git. The company says the system has cut push latency by nearly five times and now serves close to a petabyte of Git data each day. Its design targets a pressure point that’s becoming familiar across large software teams: more parallel work means conventional Git servers spend more time coordinating writes and preparing data for clients.
That pressure is especially visible at OpenAI, where agent-assisted coding is driving a sharp rise in repository activity. The company says quarterly commits to its monorepo are expected to be more than 2,400% higher by the end of this year than in the first quarter of 2024. Those numbers place Pando in a broader shift toward development systems that must handle many workers—human and automated—making changes at once.
GitHub has described its own work to improve infrastructure for faster, more reliable service at a scale of billions of pull requests per month. Its discussion at the recent Universe keynote covered efforts to adapt Git infrastructure for agent-scale development. New projects are also exploring how repositories and collaboration tools should change: Entire, from former GitHub CEO Thomas Dohmke, and Cursor’s Origin build on Git, while Anthropic’s Scion takes a fresh approach to the client and architecture.
Keeping Git while changing the server
OpenAI’s starting point was a practical one: retain compatibility with the Git ecosystem and address the server behavior that was making its monorepo unreliable. The team reported reliability below 90%, alongside slow fetches and failed merges. Its engineers, Aaron Friel, Taylor Blau, and Ted Nyman, framed the investigation around a distinction: had the company reached a limit in Git itself, or in how it served the repository?
Their conclusion was that the Git client and protocol weren’t the main constraint, although OpenAI is making some client and protocol changes. The larger issue was the architecture of conventional Git servers. “For more than two decades, developers have adapted their tools around Git as the way they build software has changed,” the engineers wrote. “When we started to feel friction in our own monorepo, it mattered to us that we could keep building on that work.”
Pando changes how the server handles branches and packfiles, the bundles of compressed Git objects sent between clients and servers. Many Git servers coordinate updates across every branch and construct a custom packfile for each fetch. Pando removes both assumptions from its core design.
In Git, a branch is a reference to a commit. Updating that reference is the part of a push that needs coordination. A traditional server orders those updates across the repository, so simultaneous work on different branches can create unnecessary contention. Pando coordinates updates branch by branch. A push to one branch can proceed without waiting for an unrelated branch’s update.
That choice allows different branches to appear at slightly different points in time when a client checks several of them. OpenAI’s view is that the tradeoff works for its use case: developers and agents generally need a consistent sequence of updates within the branch they’re working on, rather than a single synchronized view across the entire repository.
Reusable packs shift work away from fetches
Pando also changes the path a push takes through the system. It validates an incoming packfile while streaming it into blob storage, without first unpacking it into a local repository. The backend then records the branch tip, the pack’s location, and its dependencies in a metadata store.
For feature-branch pushes, Pando advertises the trunk branch as the default base. That keeps the advertised history compact and makes a pushed pack reusable by other clients that already have the trunk history. When a client fetches a branch, Pando checks the history that client already has, selects the stored packs it needs, and provides download links using packfile-uri, a Git protocol feature for fetching packs separately.

A caching layer called Express delivers the packs from regional caches. OpenAI says its cache hit rate exceeds 99%; on standard cloud virtual machines, clones and fetches can reach the limit of a 10 Gbps network connection. The approach shifts much of the work from generating a new, client-specific pack on demand to serving pack data the system already stores.
Pack reuse creates a storage management challenge of its own. A busy monorepo could otherwise leave clients downloading tens of thousands of small packs each day. Pando’s background workers periodically merge packs into larger ones, similar to compaction in a log-structured database. The backend retains packs at each compaction level and can identify the packs a client needs in logarithmic time.
The tradeoffs behind Pando’s design
Conventional Git servers typically determine which objects a client lacks and compress a fresh pack for each fetch. OpenAI says generating those packs consumes resources and makes caching difficult. Pando’s stored packs let it avoid repeating that work for every reader.
Pushes involve a different compromise. A standard server tells the client about all the branches it holds, allowing the client to avoid sending objects the server already has. At a repository with millions of branches, that list can exceed 100 MiB, according to OpenAI. Pando keeps the list small by advertising trunk alone. The cost is that repeat pushes to the same feature branch may resend objects not present on trunk. OpenAI considers that acceptable because the median pack in its monorepo is still smaller than 20 KiB.
Traditional servers also repack and garbage-collect repositories to keep them operating efficiently, tasks that consume compute and disk I/O. Pando keeps its packs and serves from multiple compaction levels. That decision underpins its reuse model, while making pack selection and storage organization central parts of the backend.
For developers, the switch is intended to require little change to daily work: they continue using standard Git commands. OpenAI does ship its own Git build to developer machines and inside the ChatGPT desktop app, reflecting the client adjustments needed to work well with the backend.
The company says it built Pando in Rust over 10 weeks. One engineer designed the core, while teams of Codex agents implemented it. The system entered production in April. Those details make the project a notable example of agent-assisted engineering being used to build infrastructure that, in turn, supports a higher volume of agent-assisted development.
Git client changes are reaching the public project
Pando depends heavily on packfile-uri, a capability first proposed by a Google engineer in 2019. Supporting its use at OpenAI’s scale exposed rough edges in Git clients, particularly around concurrent pack downloads, interrupted transfers, and resuming downloads that had already completed. OpenAI also added tracing to help identify whether a slow fetch is spending its time generating packs or transferring them.
Some of the changes have already been accepted into Git. Others remain in OpenAI’s public Git repository, including support for downloading and indexing packs in parallel and a feature called “explicit haves.” That feature lets a server tell a pushing client where a branch currently points while preventing the client from omitting that history from its pack. OpenAI is tracking the work through a public patch tracker.
The backend itself isn’t open source. OpenAI says it’s exploring ways to share the underlying technology with users, but hasn’t announced a release of Pando. Anthropic has likewise said it doesn’t plan to release Scion. For now, the most transferable part of OpenAI’s work is the set of Git client improvements: they show how established tools can adapt as repositories absorb more parallel, automated contributions. Pando’s longer-term test will be whether its branch-level coordination and reusable packs continue to deliver as that workload grows.
The post OpenAI built itself a new Git backend, too appeared first on The New Stack.