OpenAI's Pando backend cuts Git push latency by 5x for agentic coding

OpenAI has replaced its standard Git server infrastructure with a custom backend called Pando to support the massive increase in code commits generated by its developers and AI agents. Launched in production in April 2026, the system was built in just ten weeks using Rust and significantly reduces push latency while handling nearly a petabyte of Git data every day.

What happened

The shift to Pando was driven by a dramatic change in how OpenAI writes code. By the end of 2026, quarterly commits to the company’s monorepo are projected to increase by over 2,400% compared to the first quarter of 2024. This surge is largely attributed to the widespread adoption of agentic coding tools, which generate code at a pace far exceeding human-only development teams. The existing Git infrastructure struggled to keep up, with reliability dropping below 90% due to slow fetches and failed merges.

While some companies like Anthropic have chosen to abandon Git entirely in favor of new architectures, OpenAI decided to remain within the Git ecosystem. The engineering team, including Aaron Friel, Taylor Blau, and Ted Nyman, determined that the bottleneck was not the Git protocol itself, but rather how conventional Git servers manage state and coordinate writes. They sought a solution that would retain compatibility with existing developer tools while removing the performance ceilings imposed by traditional server designs.

The result is Pando, a backend that decouples branch coordination and eliminates the need to generate custom packfiles for every client request. The system went live in April 2026 and now serves close to a petabyte of Git data daily. OpenAI reports that push latency has been cut by nearly five times, allowing both human developers and AI agents to work without the friction that previously plagued their workflow.

How it works

Pando fundamentally changes two assumptions made by standard Git servers. First, it does not require every branch in the repository to be in a consistent state simultaneously. Second, it stops building a unique, compressed packfile for every single client fetch. In traditional Git, a branch is just a pointer to the latest commit, but servers usually order updates across the entire repository. This means a push to one branch can block another if they are unrelated. Pando handles each branch independently, so pushes to different branches do not wait on each other. The tradeoff is that a client viewing multiple branches might see them at slightly different points in time, but OpenAI argues this is acceptable since users primarily care about the linear history of a single branch.

When a client pushes code, Pando validates the incoming packfile as it streams directly into blob storage, without unpacking it into a local repository. It records the new branch tip and metadata in a key-value store. By default, Pando only advertises the trunk branch as a base for feature branches. This strategy ensures that most packfiles are reusable by other clients who already have the trunk history. When a client fetches code, Pando selects the necessary stored packs based on the client’s existing history and returns download links using the packfile-uri Git protocol feature.

A caching service called Express serves these packs from regional caches, achieving a hit rate above 99%. To prevent clients from downloading tens of thousands of small packs, background workers merge them into larger files over time, similar to how log-structured databases compact data. This allows Pando to determine which packs a client needs in logarithmic time. On standard cloud VMs, this architecture allows clones and fetches to max out a 10 Gbps network link, a significant improvement over the compute-heavy repacking and garbage collection required by traditional servers.

Key details

• Pando reduced push latency by nearly 5x compared to the previous infrastructure.
• The system currently serves close to a petabyte of Git data per day.
• Quarterly commits to OpenAI’s monorepo are expected to rise by over 2,400% by the end of 2026 compared to Q1 2024.
• The backend was built in Rust in just 10 weeks, with core design by one engineer and implementation assisted by Codex agents.
• Pando achieves a cache hit rate above 99% using its Express caching service.
• OpenAI is contributing several client-side fixes back to the open source Git project, though Pando itself remains proprietary.

Why it matters

For engineering leaders and infrastructure teams, Pando demonstrates that Git can still scale to meet the demands of AI-assisted development if the server architecture is rethought. The common belief that Git is inherently unsuitable for massive monorepos or high-frequency automated commits is challenged here. The bottleneck was not the version control system itself, but the traditional server model that prioritizes global consistency and on-the-fly compression. By relaxing consistency requirements across unrelated branches and leveraging immutable blob storage, OpenAI achieved massive throughput gains without forcing developers to learn a new tool.

This approach also highlights the changing role of AI in building infrastructure. The fact that a critical internal system was implemented in ten weeks with significant assistance from AI agents suggests a future where foundational tooling can be iterated upon much faster. However, it also underscores the immediate pressure these tools place on existing systems. As more organizations adopt agentic coding, they will likely face similar scalability walls. Understanding how to decouple write coordination and optimize read paths will become essential knowledge for platform engineers.

What you can do

• Evaluate your current Git server’s performance under high-concurrency write loads, especially if you are introducing AI coding assistants.
• Investigate the packfile-uri protocol feature in your Git clients to enable more efficient pack downloads and caching.
• Consider whether your team truly requires global branch consistency or if independent branch handling could reduce contention.
• Monitor the size of your reference advertisements; if listing all branches creates large payloads, consider advertising only main or trunk branches.
• Look into log-structured merging strategies for your artifact storage to reduce the number of small files served during fetches.
• Review OpenAI’s public patch tracker for Git client improvements related to concurrent downloads and transfer tracing.