Skip to content
Beta
All articles

OpenAI's Pando and the Pierre deal: why agent-scale Git stayed Git

OpenAI published Pando, a Git-compatible backend built for concurrent agent work, and said it will acquire Pierre. What is available today, and what is not.

By The SpanDock team

7 min read

A diagram comparing one coordination point that every branch push must pass through with Pando's design, where unrelated branches update independently and readers fetch stored packfiles

Two OpenAI posts in the same week describe the same pressure from opposite ends. On 2 November the company explained Pando, an in-house Git backend built because Codex made it normal for one engineer to have several changes in flight at once. On 4 November it said it will acquire Pierre Computer Company, whose file-tree and diff libraries already sit inside the Codex app, and whose Code Storage product lets other apps keep history with Git. The shared claim is that source control, not only the model, now has to cope with agent-parallel work. The shared caution is that almost none of this is a product you can buy today.

What broke in a monorepo full of agents

The Pando essay is written by Aaron Friel, Taylor Blau and Ted Nyman. They describe a familiar compounding loop. Codex lets engineers do more work in parallel: more branches and pushes, more merges, more fetches from development environments, research jobs and CI. One engineer now has several changes ready for CI at once, and each push can set several jobs fetching the same commit.

By late last year their monorepo systems were struggling. Fetches and pushes were slow, merges failed, and reliability at times fell below 90 percent. The question they posed is the useful one for any team hitting the same wall: had they reached a limit of Git itself, or of the way they served the monorepo?

They decided it was the serving layer. Git grew up exchanging patches to the kernel by email, and they wanted to keep the workflow their engineers and agents already used. Pando is a new backend that speaks the Git protocol and works with the Git client. In production it now powers all development in OpenAI's monorepo.

Two numbers appear for the same improvement. Early in the essay, Pando "cut median push latency by nearly 5x." Later, switching to Pando "reduced the latency of the median push by nearly 80 percent." Those statements describe the same change: a fivefold cut leaves about 20 percent of the original time, which is an 80 percent reduction. The essay also says Pando delivers nearly a petabyte of Git data per day, has served more than 57 terabytes of Git packs in a single hour, and sees cache hit rates of more than 99 percent on its pack delivery tier. Those figures are OpenAI's own production claims for its monorepo, not independent benchmarks.

What Pando changes, and what it gives up

Most distributed Git designs keep a consistent snapshot of every branch. Pando does not. The authors dropped two assumptions that make ordinary Git servers expensive at their scale.

The first is repository-wide consistency. Coordinating every ref update so that all branches move in one global order makes unrelated pushes wait on one another. Pando instead updates each branch independently and offers causal consistency: a reader fetching a branch sees the history that produced that tip, but a reader looking at several branches can see them at different points in time. Clients only conflict when they push to the same ref at once. The authors say users and agents in practice depend on the order of updates to a single reference, not on a global ordering of every branch.

The second is a unique packfile for every client. Computing a custom pack that omits objects the client already has costs CPU and disk I/O. Pando stores the pack a writer uploaded and reuses it. A client may download some objects it already has; the server can serve the same bytes to many readers with little computation.

On a push, Pando streams the incoming pack into a blob store and records a ref version in a metadata store. It does not unpack the pack into a local repository. By default, when a client pushes a new feature branch, Pando advertises only a designated trunk as a base. That keeps the advertisement from growing with the number of branches. The trade-off is that successive pushes to a side branch send that history outside trunk again. In their monorepo the median packfile produced this way was under 20 KiB, and the 99th percentile was under 3 MiB.

On a fetch, Pando maps the client's have and want sets to stored packs and returns them through packfile-uri, which lets the server hand back links instead of a single inline pack. OpenAI contributed improvements to that feature upstream.

Background compaction then combines small packs the way a log-structured merge-tree does, so a client that is a day behind does not download tens of thousands of individual files.

The essay also models two more conventional approaches: three-phase commit across complete replicas, and a shared write-ahead log in object storage. A simulation on the page is labelled "synthetic teaching models, not production benchmarks." Do not read those animation results as measured timings. The production claims are the ones attached to their monorepo.

They built Pando with Codex in ten weeks, began serving production traffic in April 2026, and first deployed it as a read- and write-through proxy. The core was designed by one engineer, implemented by teams of agents, and deployed by a handful of engineers. They wrote a conformance suite against standard Git behaviour and used deterministic simulation to find race conditions.

They also shipped their public distribution of Git to developer machines and contributed fixes around concurrent pack downloads and packfile-uri tracing upstream.

The Pierre announcement, read carefully

Two days later, OpenAI said it will acquire Pierre. Pierre is the company behind Code Storage and a set of open-source developer tools. If you have browsed files or reviewed a change in the Codex app, the announcement says, you have already used Pierre's Trees and Diffs libraries. Diffs' Edit mode lets a reviewer fix a line where they see the problem. Pierre also recently released Highlights, a syntax highlighter that updates as a developer types or an agent streams code. The same team designed the API for Code Storage, a service that lets apps store code and track its history using Git.

The acquisition is not closed. The post says closing is subject to customary conditions, including regulatory approvals, and that until closing the two companies remain separate and independent. OpenAI does not give a price or a date. Pierre's open-source projects "will remain open-source," and customers "can continue using Code Storage after the acquisition closes" while OpenAI works to bring its features into Codex.

The announcement ties the deal to Pando explicitly: earlier that week they had shared how they are scaling Git with Pando, and with Pierre they want to work on everything "from the first branch an agent creates" through to deployment. The ambition, once the deal closes, is "to advance the future of source control across the industry" and to make Codex the place where developers and agents take on large projects. That is a statement of intent, not a shipping plan.

What it means for engineering and security leaders

This pair of posts is most useful as a diagnosis, not as a shopping list. If your developers and agents now open many short-lived branches, and CI fetches the same tips over and over, the bottleneck may be the way your Git service coordinates writes and builds packs, not Git as a format. Anthropic's earlier move of a monorepo onto a purpose-built source-control system was one response to agent-scale merging. OpenAI's response was to keep Git's protocol and change the backend.

Do not plan a migration to Pando. The essay says OpenAI is "exploring ways to share the technology that makes Pando possible with our users." That is a "coming soon" in all but name: it is not available, it has no price, and it has no supported customer deployment. Likewise, do not treat Pierre's Code Storage as part of Codex until the acquisition closes and OpenAI says the integration has shipped. Until then the companies remain independent, and Code Storage remains Pierre's product.

What you can take from the design is more immediate. Ask your Git host how it handles concurrent pushes to unrelated branches, and whether fetch traffic is generating a unique pack for every client. If merge reliability is dipping as agent volume grows, measure push-to-fetch time and failed merges before you rewrite workflow. Review remains the constraint on how much software ships, as we noted when agents increased output; a faster push path does not review the change.

If you evaluate Code Storage or Pierre's libraries, read the licenses yourself. "Will remain open-source" is a present commitment in the announcement, not a guarantee about every future change.

Practical takeaways

  • Treat Pando as a published architecture and a set of OpenAI production figures, not as a service you can adopt this quarter.
  • Treat the Pierre deal as announced and not closed. Keep using Pierre's tools and Code Storage under their current terms until OpenAI says otherwise.
  • If agent parallelism is stressing your monorepo, measure push latency, fetch time and merge failures before changing hosts or workflows.
  • Ask your Git provider whether unrelated branch updates contend on a single coordination point, and whether fetches rebuild a pack per client.
  • Follow OpenAI's upstream Git work if packfile-uri or parallel pack downloads would help your own servers; those contributions are useful without running Pando.
  • Do not describe either system as generally available to customers. The Pando essay says sharing it is being explored; the Pierre post says the acquisition still needs to close.

Sources

  1. OpenAI: Scaling Git at OpenAI
  2. OpenAI: OpenAI to acquire Pierre Computer Company, Inc.
Cookie categories

Details: Cookie Policy.