OpenAI's Pando: Scaling Git for Agent‑Scale Development

Introduction

OpenAI’s rapid expansion of Codex has pushed its monorepo to unprecedented levels of concurrent activity. Engineers now manage dozens of branches, frequent pushes, and heavy fetch workloads from CI pipelines, research jobs, and automated agents. The existing Git service, designed for a much smaller community of kernel contributors, could not sustain the reliability and performance demands of this scale. To keep the familiar Git workflow intact while solving the underlying bottlenecks, OpenAI built Pando—a new, Git‑compatible backend that delivers horizontal write scaling and high read throughput. The result is a system that now serves nearly a petabyte of Git data each day and cuts median push latency by roughly five times, all without disrupting the engineers’ daily Git usage.

Why a New Source Control System Was Needed

The growth of agentic development introduced two compounding pressures. First, each engineer could prepare multiple changes for CI simultaneously, generating a surge of parallel pushes across many branches. Second, each push triggered multiple jobs to fetch the same commits, creating heavy read load for a shared history. By the end of last year, the monorepo’s Git service was falling below 90% reliability, with slow fetches, sluggish pushes, and occasional merge failures. These symptoms indicated that the current architecture could not keep pace with the scale of work that Codex enables.

The decision to build a new backend was driven by two core requirements: preserve Git protocol compatibility so that both human engineers and autonomous agents could continue using existing tools unchanged, and redesign the storage and coordination layer to support many writers and many readers efficiently. Pando addresses both dimensions while allowing OpenAI to contribute improvements back to the upstream Git project.

Engineering for Git at Scale

Git’s model of objects and references provides a solid foundation, but the way those objects are stored and transferred becomes a bottleneck at scale. OpenAI examined three common patterns for scaling Git:

• Distributed Git services that replicate objects across multiple nodes.
• Three‑phase commit (3PC) and write‑ahead logs (WAL) for coordinated updates.
• Packfile‑centric delivery where each client receives its own compressed bundle.

Each approach offered trade‑offs in consistency, latency, and storage efficiency. The OpenAI team ultimately selected a design that decouples branch updates, reuses packfiles across fetches, and leverages causal consistency to keep writes independent while allowing readers to see slightly divergent branch states.

Key engineering choices include:

• Independent branch coordination – updates to unrelated branches proceed in parallel, enabling high write throughput.
• Packfile reuse – a single packfile can serve many clients, reducing server‑side computation and bandwidth.
• Causal consistency – readers may observe different points in time for different branches, which is acceptable for CI and agent workflows that rarely require a globally synchronized view of all branches.

These decisions allow Pando to scale writes across dozens of concurrent branches while delivering read performance that can saturate available network links.

Pando Architecture and Performance

Pando sits beneath the Git protocol, presenting the same object storage and reference resolution semantics that clients expect. Internally, it separates the storage of Git objects from the coordination of references, using a distributed object store that can serve millions of objects per day.

The system’s write path processes each branch independently. When a push arrives, Pando validates the pack, extracts new objects, and updates the branch’s ref atomically. Because branches are isolated, parallel pushes to different branches can be processed concurrently, eliminating contention that would otherwise limit throughput.

For reads, Pando aggregates packfiles at the storage layer. Instead of generating a fresh pack for each fetch, it selects a superset of objects that satisfies the requested history and serves that pack to multiple clients. Clients may receive duplicate objects, but the server’s computational cost remains low, and network bandwidth is fully utilized.

Performance measurements after deployment show a median push latency reduction of roughly five times compared with the previous Git service. Daily data transfer now approaches one petabyte, reflecting both the increased volume of commits and the higher efficiency of packfile reuse. Reliability has risen well above the 90% threshold that was problematic before, and the system continues to handle spikes during large‑scale code generation tasks.

Deployment and Practical Mitigation

Deploying Pando required zero downtime for engineers. The backend was introduced as an additional Git server, and DNS round‑robin or load‑balancer weights were adjusted to shift traffic gradually. Because the Git protocol remains unchanged, existing hooks, CI configurations, and local clones continue to work without modification.

Organizations facing similar scaling challenges can adopt a comparable strategy:

• Assess write parallelism – identify branches that are updated concurrently and consider isolating their coordination.
• Reuse packfiles – implement a cache layer that serves the same compressed bundle to multiple fetch requests.
• Accept causal consistency – evaluate whether reads need a strict global snapshot or can tolerate slight divergence across branches.
• Monitor latency and throughput – track push and fetch metrics to ensure the system saturates network capacity.

By following these practices, teams can retain the Git client experience while gaining the horizontal scalability that modern agentic workflows demand.

Conclusion

Pando illustrates how a carefully engineered, Git‑compatible backend can meet the extreme demands of agentic development while maintaining the simplicity that developers have come to rely on. OpenAI’s experience offers valuable insights for any organization planning to scale its source control infrastructure. By adopting horizontal write scaling, packfile reuse, and causal consistency, teams can achieve the performance needed for modern AI‑driven coding workflows. Grivyonx’s AI automation and DevSecOps services can help design and secure similar scalable Git backends for enterprises looking to future‑proof their development pipelines.