OpenAI has launched Pando, a new Git backend that now handles all development traffic for its internal monorepo. The system retains the standard Git client and protocol, meaning engineers and Codex agents continue to run git push and git fetch without change. Only the server infrastructure has altered. The OpenAI team reports median push latency has fallen by nearly 80%. Pando now processes almost a petabyte of Git data daily.
Scale and performance
The system manages nearly 1 PB of Git data per day. Peak throughput exceeds 57 TB within a single hour. It runs on commodity hardware, with standard cloud VMs saturating 10 Gbps links during clone and fetch operations. Testing indicates thousands of concurrent pushers operate without degradation. Median push latency is down nearly 80%, roughly a fivefold improvement. The system is not open source. Repeated pushes to branches resend history outside the trunk, though the p99 pack size remains under 3 MiB.
What is OpenAI Pando?
Pando is a Git-compatible server backend designed to scale concurrent pushes and fetches for a monorepo. It was written in Rust and reached production in 10 weeks. One engineer designed the core, while teams of Codex agents implemented the rest. It has served production traffic since April 2026.
Why did OpenAI need a new Git backend?
Codex multiplied parallel work. OpenAI’s commit chart shows commits landed on master rose 1,378% in Q3 2026 versus Q1 2024. The Q4 2026 estimate is +2,442%. Each push now triggers many CI fetches. By late 2025, fetches and pushes slowed, merges failed, and reliability at times fell below 90%. OpenAI concluded the bottleneck was how it served Git, not Git itself.
How does Pando work?
Pando drops 2 assumptions that most Git servers treat as requirements:
1. Repository-wide consistency: Conventional servers order every ref update repo-wide, so unrelated pushes wait. Pando uses causal consistency instead. Each branch is serialized on its own, and clients only conflict when pushing the same ref. The tradeoff is that a reader viewing several branches may see them at different points in time.
2. A unique packfile per client: Standard servers build a fresh pack per fetch. Pando stores each pushed pack as an immutable blob. A “ref version” goes into a scalable metadata store. A push needs O(1) metadata reads and writes. A fetch needs O(log Δ) reads, where Δ is the ref-version gap to close.
How are pushes kept small and reusable?
With millions of branches, a full ref advertisement can exceed 100 MiB. Pando advertises only the trunk branch as the base for new feature-branch pushes. Any reader with trunk history can then fetch that branch from 1 stored pack. In OpenAI’s monorepo, the median pack was under 20 KiB.
How are fetches served at line rate?
Pando returns download links via packfile-uri, an existing Git protocol feature. It sends an empty inline pack. A delivery service called Express caches packs regionally, using consistent hashing, with hit rates above 99%.
What replaces garbage collection?
Each push creates an “L0” pack. Background workers group packs into geometrically larger covers, similar to LSM-tree compaction. The monorepo currently uses covers up to L4. Covers act as a skip list, so pack selection runs in logarithmic time.
What are the production numbers?
All figures below are self-reported by OpenAI.
- Median push latency reduced by nearly 80%.
- Nearly 1 PB of Git data per day, using only a handful of CPU cores.
- Over 57 TB of packs served in a single hour, more than 99% from local disk cache.
- Clones and fetches saturate 10 Gbps links on standard cloud VMs.
OpenAI also ran a 1,000-writer simulation against 3-phase-commit and write-ahead-log designs. It labels these teaching models, not benchmarks.
How does Pando compare with other approaches?
| OpenAI Pando | GitHub Spokes | Anthropic Scion | |
|---|---|---|---|
| Git client compatible | Yes | Yes | No, own scn client |
| Write coordination | Per-branch, causal consistency | Three-phase commit with quorum | Server-side commits; refs via compare-and-swap |
| Default replicas | Not disclosed (blob + metadata stores) | 5 full copies | No fully materialized repo copy |
| Read path | Reused packs via packfile-uri, Express cache | Closest in-sync replica | Tiered tree/blob caches |
| Cache hit rate | Over 99% | Not disclosed | Over 99% per tier |
| Headline result | Median push latency down ~80% | Serves ~1 billion repositories | 200x smaller CPU/memory footprint |
| Build effort | 10 weeks, Rust | Not disclosed | 7 people, 5 months |
| Available to others | No | Yes, powers GitHub | No |
How was Pando built and deployed?
OpenAI wrote a Git conformance suite for agents and added deterministic simulation testing. Agents using GPT-6 Astra wrote Lean and TLA+ specs to find bugs.
Pando first ran as a read- and write-through proxy, so traffic moved without downtime. OpenAI ships its own Git build to developer machines and the ChatGPT desktop app.
What goes back to upstream Git?
OpenAI fixed client handling of concurrent, interrupted and resumed pack downloads, and added packfile-uri tracing. Its build adds parallel pack indexing and “explicit haves.” Several fixes are upstream. The rest sit in a public patch tracker.
What are the limitations?
- Pando is not open source; OpenAI team states that it is exploring ways to share the technology.
- Cross-branch reads have no single point-in-time snapshot.
- Repeat or stacked branch pushes resend everything outside trunk. The p99 pack was under 3 MiB.
- Every performance number is self-reported, with no independent benchmark yet.
What it means for developers
For the people building code, the change is mostly invisible to the command line but significant for the workflow. Engineers do not change their habits; they still type git push. However, the system now handles the internal load of Codex agents and high-volume CI checks without slowing down. This allows the monorepo to scale to nearly 1 PB of data daily without the reliability issues seen in late 2025. The tradeoff is that the backend remains internal, so other teams cannot adopt the same architecture immediately.
