Coding agents are changing something that once looked settled: how Git repositories are hosted and distributed.

On November 2, 2026, OpenAI introduced Pando, the new backend already serving development on its monorepository. Pando is not a programming language, a new Git command, or a replacement Git client. It is the infrastructure answering engineers’ and agents’ push, fetch, and clone requests.

The announcement reflects a fundamental shift: when one engineer can delegate several tasks to Codex simultaneously, source-control traffic no longer resembles a conventional human development workflow.

The numbers behind the change

OpenAI reports these production results:

  • Nearly 80% lower median push latency, or roughly a fivefold improvement.
  • Nearly one petabyte of Git data delivered daily.
  • More than 57 terabytes of Git packs served in one hour, with over 99% of those bytes coming from local disk cache.
  • clone and fetch throughput able to saturate 10 Gbps links in tests using ordinary cloud virtual machines.
  • An initial implementation developed in 10 weeks, with Codex contributing to engineering work.

These are OpenAI’s own infrastructure measurements, not a guarantee of comparable performance for other repositories.

The bottleneck

In a conventional workflow, a developer prepares a branch, makes changes, pushes, and waits for CI. With coding agents, the same developer can produce several branches ready for testing at almost the same moment. Every push can trigger further downloads from CI jobs and development environments.

OpenAI says its monorepo infrastructure had begun experiencing slow fetches and pushes, failed merges, and periods when reliability fell below 90%.

The underlying constraint was not necessarily Git’s format or protocol. It was how a shared repository was being served to a much larger population of concurrent writers and readers.

Pando’s central idea: keep Git, change the backend

Pando preserves familiar Git commands and protocol compatibility. Its internal layout is different:

engineers + Codex agents
           |
       git push/fetch
           |
        Pando
        /   \
   metadata  immutable packfiles
        \   /
    distributed storage
           |
     regional caches
           |
           CI

The architecture separates two jobs: publishing branch updates and delivering Git objects to clients.

1. Independent branches can advance independently

Traditional distributed Git serving can rely on synchronizing complete replicas or updating a global shared log. That means a push to one branch can contend with a push to another unrelated branch.

Pando instead records versions for each reference and atomically updates that reference’s pointer. Two agents pushing to unrelated branches can make progress in parallel; writers racing to update the same branch must still resolve the conflict.

The tradeoff is causal consistency, not a repository-wide, perfectly synchronized snapshot of every branch. A client reading two different branches can observe them at different instants. The stronger ordering guarantees apply to each individual reference and its dependencies.

That weaker global view is a deliberate architectural choice, not an incidental implementation detail.

2. Fetches reuse existing Git packs

A conventional Git server computes which objects each client lacks and generates a compressed pack tailored to that client’s state. Repeated across many agents and CI jobs, that can become expensive CPU and I/O work.

Pando retains the packfiles received during pushes and stores metadata describing their dependencies. When a client fetches, the server selects reusable packs that cover the requested history instead of recomputing one unique pack for every client.

It also deliberately advertises fewer references during push negotiation. This can mean some redundant bytes are uploaded, but it makes the resulting pack much easier to reuse safely. OpenAI reports a median pack below 20 KiB for this strategy in its monorepo.

An associated delivery service named Express uses regional caches so many clients can retrieve the same bytes with little repeated computation.

3. Background compaction prevents tiny-pack overload

Reusing every incoming pack individually would create another problem: a client that is far behind might need thousands of small downloads.

Pando groups packs in the background using compaction levels reminiscent of LSM structures. This reduces the number of transfers and accelerates the selection of packs spanning the needed history. OpenAI says its monorepo currently uses covers up to level L4.

The twist: Codex helped build the system it needed

According to OpenAI, the core architecture was designed by one engineer, implemented with teams of coding agents, and deployed by a small group of engineers. Pando began handling production traffic in April 2026.

The implementation is written in Rust. Its correctness checks include a Git conformance suite, deterministic concurrency simulations, and formal work in Lean and TLA+, assisted by agents using GPT-6 Astra.

This is not a story of uncontrolled autonomous deployment. The engineering account describes systematic validation and a staged rollout, initially running Pando as a read/write-through proxy against the previous backend.

The striking feedback loop is that agents both created the scaling pressure and helped build the infrastructure to handle it.

Does Pando replace GitHub? Can developers install it?

Not as described in this announcement. Pando is OpenAI’s internal Git-serving backend, not a newly available public collaboration platform.

OpenAI says it is exploring ways to share the technology, but its November 2 post does not announce an open-source Pando release. The company does describe fixes and optimizations it has contributed, or is working to contribute, to Git itself: parallel downloads, pack validation and resumption, tracing, and protocol improvements.

For a small team already using GitHub, the immediate benefit is understanding the engineering ideas, not switching servers.

What engineering teams should take away

The important measure of an agentic engineering system is no longer only how much code an agent can write. It is how much parallel work the surrounding infrastructure can absorb without overwhelming branches, source-control servers, or CI.

Smaller teams can apply the principle through task-isolated branches, reproducible tests, dependency caching, concurrency budgets, and automated checks before merging. None of those practices requires Pando.

Pando does, however, point toward a broader trend: as agents increase the rate of software changes, version-control infrastructure becomes an important constraint on the speed of development itself.

Sources