OpenAI Builds Pando: Scaling Git for Agent-Scale Development

OpenAI has announced the development of Pando, a revolutionary new backend designed to handle the immense scaling demands placed on source control systems, specifically targeting the needs of their massive monorepo. This initiative was necessitated by the exponential growth in development complexity and concurrent work enabled by advanced AI tools, such as Codex. The sheer scale of parallel development—involving numerous engineers, research jobs, and CI pipelines—created unprecedented demands on the existing Git infrastructure, leading to significant performance bottlenecks, including slow fetches, slow pushes, and reliability issues that occasionally dropped below 90%. The team recognized that while Git itself is a robust system, the way the monorepo was served and managed was reaching its operational limit, requiring a fundamental overhaul of the backend while preserving the familiar and critical Git workflow for all users, including automated agents.

Pando was engineered with two primary, ambitious goals: achieving horizontally scalable writes, which means optimizing for concurrent pushes across many different branches, and maximizing read throughput, ensuring that clients can download data fast enough to fully saturate their available network bandwidth. By achieving these goals, Pando successfully powers all development within OpenAI’s monorepo. Crucially, the system was designed to maintain full compatibility with the established Git protocol and client tools. This compatibility was vital, as it allowed both human engineers and sophisticated AI agents to seamlessly adopt Pando into their existing, deeply ingrained workflows without requiring a massive, disruptive migration of tools or processes. In real-world production testing, Pando demonstrated a dramatic improvement, cutting the median push latency by nearly five times, and it now manages the transfer of nearly a petabyte of Git data every single day.

The decision to build a new backend while retaining Git compatibility was strategic. The team understood that Git formed the foundational bedrock of their source-control workflow. By building improvements on top of Git's established model, they ensured that the resulting advancements would not be confined to OpenAI but could be contributed back to the broader, upstream Git community, benefiting the entire developer ecosystem. This approach allowed them to solve internal scaling problems while simultaneously contributing to the global standard of software development tooling.

Scaling a source control system inherently involves managing two distinct, yet equally critical, dimensions: the high volume of many writers pushing updates to various branches, and the equally high volume of many readers fetching the same historical data. Pando addresses both dimensions through sophisticated architectural choices. Firstly, Pando coordinates updates to each branch independently. This means that updates occurring on unrelated branches can proceed in parallel, significantly boosting write scalability. When a reader fetches a specific branch, they receive the precise history needed for that revision. However, the architecture notes a necessary trade-off: a client attempting to view several different branches simultaneously might see them at slightly different points in time, reflecting the independent update cycles.

Secondly, and perhaps most efficiently for read performance, Pando implements a mechanism to reuse packfiles across multiple client fetches. In traditional systems, generating a packfile (Git’s optimized format for compressing multiple objects) might involve creating a unique file for every client. Pando avoids this computational overhead by serving the same underlying bytes to many different clients. A client might request some objects that it already possesses locally, but the server can efficiently serve those same bytes to numerous users with minimal additional computation, drastically improving read efficiency and reducing server load. These combined strategies—parallel branch updates for writes and cache-optimized packfile reuse for reads—are what enable the system to scale effectively across the massive demands of modern AI-driven development.

To fully appreciate Pando's technical achievement, one must understand the underlying mechanics of Git itself. At its core, a Git repository must keep two interconnected parts synchronized: the objects and the references. Git records snapshots of files and the entire history connecting them, which is structured as a directed acyclic graph (DAG) of objects. The objects themselves are categorized into several types: Blobs, which simply hold the raw content of an individual file; Trees, which are responsible for associating names with blobs or other trees, thereby forming the hierarchical directory structure; Commits, which point to a root tree and zero or more parent commits, thereby defining the historical lineage; and Tags, which are pointers to specific points in history. All objects are identified by a unique hash derived from their type and content, and they are fundamentally immutable. If a file changes, a new blob is created; if it remains unchanged, the existing object is reused, which is key to Git's efficiency.

References, or 'refs,' are the pointers that make the history accessible. They are what point to specific commits. When a developer commits to a branch, a new commit is created, and the branch's reference is updated to point to this new commit. The entire structure is interconnected: Git objects reference each other by their unique IDs, commits point to trees, and trees point to other trees and blobs. For instance, the branch reference refs/heads/main points to a specific commit (C2). This commit C2, in turn, points to a root tree (T2), which dictates that a file like parser.py refers to a specific blob (B2). The parent commit (C1) points to a different root tree (T1), where the same file name parser.py might refer to a different blob (B1). This complex, interconnected graph structure is what Git manages, and Pando's ability to scale this graph management to petabyte levels while maintaining compatibility is the core technical feat of the project. The ability to handle petabytes of data daily while maintaining near-original Git compatibility is the defining achievement of Pando, enabling the next generation of agent-scale development.