
OpenAI’s engineers watched their Git infrastructure buckle under a workload it was never designed for: fleets of AI agents committing code around the clock. Their fix wasn’t to abandon Git, it was to tear out its backend and rebuild it in ten weeks. The result, Pando, reportedly cut push latency by 80% and now handles a petabyte of Git traffic a day.
OpenAI Pando is best understood not as a one-off engineering flex but as the opening move in an industry-wide race to rebuild version control for agentic coding. Its “keep Git, replace everything behind it” philosophy stands in direct contrast to rivals betting on replacing Git entirely, and that split will shape how every AI-heavy engineering organization thinks about its source control for the next several years.
Why Agentic Coding Breaks Conventional Git
Git was designed around a human cadence. A developer writes code, commits a handful of times an hour at most, pushes a branch, opens a pull request, and waits. The system’s object storage, ref-update logic, and locking model all quietly assume that commit traffic is bursty but bounded, that concurrency is measured in dozens of engineers, not thousands of autonomous processes.
Agentic coding shatters those assumptions. When OpenAI Codex agents operate against a repository, they don’t commit at human pace. They commit in surges: dozens or hundreds of branches created in parallel, each with its own rapid-fire commit history, each pushing to the same central repository. The traffic profile shifts from “steady trickle with occasional spikes” to “continuous high-concurrency load with no natural quiet period.”
This is the mismatch at the heart of scaling Git at OpenAI. Git’s backend, the object database, the pack-file storage, the ref-update machinery, was never engineered for bounded-concurrency-at-scale. Its frontend, the protocol, the CLI, the mental model developers hold, is beloved and deeply entrenched. The problem was never Git’s interface. It was everything underneath it.
The stakes are not abstract. Infrastructure that throttles agents throttles the product. If a Codex agent has to wait on a slow push, the agent’s effective throughput collapses, and the entire value proposition of autonomous coding degrades. For OpenAI, a monorepo at AI scale isn’t a nice-to-have, it’s the substrate the product runs on. When that substrate becomes the bottleneck, you either fix it or you ship a slower product.
The Pando Rebuild and the Competitive Landscape
What Pando Actually Is
OpenAI Pando is a purpose-built Git server that replaces the storage and serving backend of Git while preserving the Git protocol and every developer workflow layered on top of it. The philosophy is deceptively simple: keep Git, rebuild behind it. Developers still git clone, git push, and git pull. Their tooling doesn’t change. Their mental model doesn’t change. But the machinery answering those commands is no longer stock Git, it’s a system engineered from the ground up to absorb high-concurrency agent pushes.
Mechanically, that means rethinking the parts of Git that choke under load. A conventional Git server serializes ref updates and manages object storage in ways that degrade as concurrent writers multiply. Pando’s job is to make those operations scale horizontally, to handle the commit surges that OpenAI Codex commits generate without the latency cliffs that stock Git exhibits. OpenAI reports that Pando delivers 80% faster pushes and sustains roughly a petabyte of Git traffic per day. Those are striking numbers, and they’re worth sitting with: a petabyte a day is not a rounding error. It’s the kind of figure that only makes sense once you accept that machine-paced commits have fundamentally changed the traffic profile of a repository.
The rebuild took ten weeks, a timeline that says as much about OpenAI’s engineering culture as it does about the problem. This wasn’t a multi-year platform migration. It was a focused strike at a specific bottleneck by a team that had already decided the existing approach was a dead end.
There’s an underreported detail that reframes the whole effort: OpenAI’s acquisition of Pierre, a code review company. On its own, buying a review tool looks like a modest product move. In context, it’s a signal about owning the commit path end to end. If you control the author (Codex), the store (Pando), and the review (Pierre), you control the entire lifecycle of a line of code from generation to merge. That’s not a performance story. That’s a vertical integration story.
The Comparative Axis: Rebuild vs. Replace
Pando doesn’t exist in a vacuum. Across the industry, teams hitting the same agent-scale wall are splitting into two camps, and the split is the most important structural fact in this space right now.
The “rebuild behind Git” camp keeps Git’s interface and replaces its guts. Pando is the flagship example. Uber’s GitFarm sits on the same side of the line, an effort to make Git survive workloads it wasn’t built for while preserving compatibility. The appeal is obvious: migration cost approaches zero for developers, existing tooling keeps working, and you get the performance gains without asking anyone to relearn their job.
The “replace Git” camp argues the interface itself is the problem. Anthropic’s Scion and Cursor’s Origin are betting on greenfield, agent-native designs that discard Git’s assumptions entirely rather than working around them. The open-source Aspen project occupies similar territory. The pitch here is that if you’re designing for a world where agents, not humans, are the primary committers, you shouldn’t inherit a data model built for human cadence, you should build the right thing from scratch.
The trade-off is stark and worth stating plainly. Rebuilding behind Git optimizes for compatibility and migration cost. Replacing Git optimizes for greenfield agent-native design, the freedom to make concurrency, branch explosion, and machine-paced commits first-class from day one, unburdened by decades of legacy assumptions. Neither camp has won. But the existence of the split tells you something important: nobody believes stock Git is sufficient for the agentic era. The only disagreement is whether to renovate the house or tear it down.
Vertical Integration and the GitHub Question
Step back and the shape of OpenAI’s strategy comes into focus. Codex authors the code. Pando stores it. Pierre reviews it. That’s the full code lifecycle, assembled in-house, each piece tuned to the others. When your authoring tool generates machine-paced commit traffic, and your storage backend is purpose-built for exactly that traffic, and your review layer is owned and integrated, you’ve built something a generic platform can’t easily match.
This is why an internal-only Git backend is a structural challenge to GitHub’s position, not merely a performance footnote. GitHub’s dominance rests on being the neutral, universal home for code, the place where everyone’s tooling converges. But if the most advanced AI coding tools generate workloads that GitHub’s infrastructure handles less gracefully, and if the company generating that workload has quietly rebuilt the entire path around GitHub, the neutrality advantage starts to look like a liability. OpenAI isn’t competing with GitHub on features. It’s competing on the assumption that GitHub is the natural center of gravity for code.
Here the skeptic’s corner deserves a full hearing. Every Pando metric, the 80% push-latency reduction, the petabyte-a-day figure, the ten-week timeline, is self-reported by OpenAI, vendor-authored, and describes an internal-only system. No independent benchmark exists. No external team has reproduced the numbers. That doesn’t make them false; it makes them unverified. Treat them as claims from a credible source with an obvious interest in the narrative, and hold them at arm’s length until someone outside OpenAI puts Pando through its paces. The architecture is real and the strategic logic is sound regardless of whether the exact percentages hold up, but the specific figures should be attributed to OpenAI every time they’re cited.
What This Means for Engineering Teams
The audience most directly affected is DevOps and platform engineers, engineering leaders at AI-heavy organizations, and any team running agent fleets against a monorepo. If that’s you, the relevant question isn’t whether Pando is impressive, it’s whether you’re approaching the same wall.
A few practical signals suggest you might be. Push latency that climbs as agent concurrency rises. Ref-update contention during commit surges. Storage growth that outpaces your capacity planning because machines commit far more often than humans ever did. If your Git server’s load profile has started to look less like a team of engineers and more like a fleet of processes, you’re in Pando territory whether or not you’ve named it.
The strategic choice between “rebuild behind Git” and “replace Git” has real consequences for migration risk and tooling lock-in. Rebuilding preserves your existing workflows and tooling, low migration cost, but you’re still maintaining a compatibility layer over a system whose foundations fight you. Replacing Git means a greenfield design unburdened by legacy assumptions, but it also means asking every developer, every CI pipeline, and every integration to adapt to something new. There’s no universally correct answer; there’s only the trade-off that fits your organization’s tolerance for disruption versus its tolerance for inherited constraints.
The broader read is that version control is becoming an AI infrastructure concern, not a settled commodity. For two decades, Git was plumbing, reliable, boring, assumed. Agentic coding has turned it into a scaling problem, and scaling problems at AI companies become everyone’s problems eventually. The teams that recognize this early will make better infrastructure bets than the teams that discover it when their agents start queuing on pushes. AI-assisted development infrastructure is no longer a background concern; it’s on the critical path.
Key Takeaways
- Pando rebuilds Git’s backend rather than replacing Git, preserving developer workflows while surviving agent-scale commit surges, the defining example of the “keep Git, replace everything behind it” philosophy.
- OpenAI reports 80% faster pushes and roughly 1 PB/day of Git traffic, but these figures are self-reported, vendor-authored, and describe an internal-only system with no independent verification.
- The industry is splitting into two camps: “rebuild behind Git” (Pando, Uber’s GitFarm) optimizing for compatibility, and “replace Git” (Anthropic’s Scion, Cursor’s Origin, open-source Aspen) betting on greenfield agent-native design.
- The Pierre acquisition points to vertical integration, author (Codex) to store (Pando) to review (Pierre), a structural challenge to GitHub’s position as the neutral center of code, not just a performance upgrade.
- Agentic coding turns version control into a first-class scaling problem for every AI-heavy engineering org; if your Git load profile looks like a fleet rather than a team, you’re approaching the same wall.
What to Watch Next
The most important near-term signal is whether OpenAI publishes independent benchmarks or external teams reproduce Pando’s numbers. Until someone outside the company stress-tests the system, the 80% and petabyte figures remain credible-but-unverified claims. Watch for the first external validation, or the first quiet contradiction.
Second, watch whether Pando stays internal or surfaces as a product or API. An internal backend is a strategic asset; a productized one is a market move. If OpenAI exposes Pando to external customers, the GitHub question stops being theoretical and becomes a direct competitive front.
Third, track how the “replace Git” camp matures. Scion, Origin, and Aspen are betting that agent-native design beats compatibility. The tell will be whether any of them build Git interoperability, a bridge that would acknowledge Git’s gravitational pull even as they try to escape it.
Fourth, watch the Pierre integration. If review tooling fuses tightly with Codex and Pando, OpenAI will have assembled a closed loop where code is authored, stored, and reviewed without ever touching a third-party platform. That’s the endgame the acquisition implies.
Finally, look for early adopters reporting their own agent-scale Git walls. The first real-world accounts of teams hitting the same bottleneck, and how they solve it, will be the truest test of whether OpenAI’s approach is a template or a one-off. That’s where the story gets validated, contradicted, or rewritten.


