AI Code Volume Breaks Git: OpenAI and Anthropic Build Custom Backends
To address Git server bottlenecks caused by massive code commits from AI agents, OpenAI developed Pando to optimize existing Git infrastructure, while Anthropic built a new system called Scion. Pando reduced push latency by ~80%, whereas Scion cut CI fetch times from minutes to seconds with significantly lower resource usage. Both solutions target giant monorepos and are currently internal or shared as design concepts.
Related Entities
Full Report
Contents3 sections
Baoyu (@dotey) · 2026-11-03 05
AI generates too much code, overwhelming Git: OpenAI keeps Git but swaps the server; Anthropic builds a new system from scratch
On November 2, OpenAI published an article introducing Pando, a self-developed Git server backend. On October 13 of last month, Anthropic also released an article detailing Scion, their proprietary source code management system.
Both companies are facing the same problem: AI agents write code so fast that code management systems have become the bottleneck for overall development speed. Their solutions, however, take opposite directions.
First, some background on Git: It is a tool programmers use to manage code versions. Each change is saved as a "commit," pushed to the company's server, and colleagues then fetch it from the server. A "branch" is a parallel draft of the same codebase where changes happen independently before being merged into the main line. Both companies store all company code in a single large repository, known in the industry as a monorepo.
OpenAI’s approach is to retrofit Git.
Engineers and agents still run git push and git pull, but the server is replaced with Pando. The median wait time for pushing code has been reduced by nearly 80%, distributing close to 1PB (approximately 1 million GB) of code data daily.
Anthropic’s approach is to replace Git.
Scion has its own client and server. Commits and merges are handled entirely on the server side, along with custom-built tools for code review and code search. CI (the process of automatically building and testing after every change) now takes seconds instead of minutes to fetch code, and the CPU and memory usage on the servers is only 1/200th of the previous system.
Neither system is offered externally.
OpenAI states they are researching how to provide Pando’s technology to users. In the process, fixes made to Git have already been submitted upstream, with several included in official releases.
Anthropic notes that Scion is only suitable for massive codebases. Adopting it requires replacing code review, search, and CI tools entirely, making it difficult for other companies to use directly. Therefore, they are only sharing design insights, hoping GitHub, GitLab, and the open-source community will absorb useful parts of the architecture.
If your team uses GitHub or GitLab, OpenAI’s path is closer to you: improvements go directly into Git, requiring no change in the toolchain. Both companies believe other organizations will eventually face similar issues. Anthropic predicts these problems will become more common within the next 6 to 12 months.
Why Git Can’t Keep Up
The volume of commits is growing too rapidly. Using Q1 2024 as a baseline, the number of commits merged into the main branch at OpenAI grew to nearly 15x by Q3 2026, with projections reaching ~25x by Q4. At Anthropic, daily merged changes jumped from about 2,500 in May to over 30,000 in September—a more than 12-fold increase in four months.
Pressure compounds: An engineer often has multiple changes waiting for tests. Every push triggers several test tasks fetching the same code.
Since late last year, OpenAI experienced slowdowns in both fetching and pushing code. Merges frequently failed, and reliability dropped below 90% at one point, meaning more than 1 out of every 10 operations resulted in an error.
At Anthropic, the main branch history approaches 100GB, and the compressed working copy exceeds 25GB. CI alone fetches code approximately 25 million times per day. Full downloads would exceed 600PB daily. They once deployed hundreds of Git mirror servers to distribute the load, which became increasingly difficult to maintain.
Anthropic identified the root cause: Git was designed assuming everyone works offline, requiring each user to hold a complete local copy of the repository. Today, most fetches are performed by agents and automated tasks that remain constantly online. Carrying the entire repository locally has become a burden rather than a benefit.
Writing Code: Don’t Make Everyone Queue Up
When multiple users push simultaneously, the server must ensure that the pointer indicating "which commit this branch currently points to" (called a ref in Git, analogous to a bookmark) remains consistent.
OpenAI evaluated two common approaches, both of which require serializing changes across the entire repository.
One is Three-Phase Commit (3PC): Several servers each store a full copy of the repository. Each push requires agreement from a majority of servers through three rounds of confirmation. As push volume increases, the hard drives on individual servers become overwhelmed.
The other is Write-Ahead Logging (WAL): All changes are first recorded in a shared ledger before execution. Regardless of which branch is modified, there is contention to write to the same ledger. If the ledger updates too quickly, servers cannot keep up with applying changes, causing longer waits for others to fetch new code.
Pando’s solution is to manage each branch independently.
Pushing to Branch A and Branch B do not block each other; conflicts only occur if two people push to the same branch simultaneously. The trade-off is that when viewing multiple branches concurrently, you may see states from different points in time. OpenAI argues that humans and agents primarily care about the sequential order within a single branch.
Anthropic goes further: Commits are generated directly on the server, eliminating the push step entirely. Each commit records only which files changed.
Scion minimizes the use of branches, relying almost exclusively on the main line and release branches. This is because achieving consensus on branch state across all servers becomes problematic at scale. Both companies ultimately simplified moving bookmarks into a single "Compare-and-Swap" operation: Pando modifies a key, while Scion modifies a row in the database.
Anthropic also eliminated global queuing before merges. Traditional methods lock the repository during merges, testing changes one by one before releasing them. Anthropic noted that by the time tests finish, hundreds or thousands of changes have already been merged, making queuing impractical. Instead, they shifted to automatic testing after merging but before deployment. Simultaneously merged changes may conflict, but Claude typically resolves conflicts faster than humans can detect them.
Fetching Code: Don’t Pack Individually for Everyone
Traditional Git servers calculate a unique packfile (a format where Git compresses a batch of files together, storing only differences for similar files) on-the-fly for each requester, including only what they lack. As request volume grows, CPU and disk resources become strained. Both companies bypassed this step using opposite methods.
Pando operates like shipping standardized boxes: Packfiles uploaded by pushers are stored as-is and served directly to anyone who requests them, requiring minimal computation on the server.
To make packs universally usable, clients package against the trunk during pushes: Content already present on the trunk is excluded. Packs contain only files modified in that branch, corresponding directory listings, and commit records. After compression, the median size is under 20KB.
Background processes progressively merge small packs into larger ones to prevent users lagging behind by days from downloading tens of thousands of tiny files. The trade-off is that clients occasionally download some content they already possess.
Scion operates like a supermarket self-service model: It completely avoids packfiles. Clients request specific files as needed.
Each file is assigned an ID based on its content hash. If the content changes, the ID changes. Files with the same ID never change, allowing any cache layer to respond directly without verifying consistency with other servers.
Clients can also fetch only the directories they need, or defer downloading specific files until they are actually read.
Both systems achieve cache hit rates exceeding 99%.
Results and Implementation Details
OpenAI: Median push latency decreased by nearly 80%. The system distributes approximately 1 PB of data daily using a small number of CPU cores, with peak throughput reaching 57 TB per hour. Tests on standard cloud servers demonstrated that code fetching saturates 10 Gbps network bandwidth.
Anthropic: Server CPU and memory usage dropped to 1/200th of the original Git mirror. Code fetching for CI and research tasks became two orders of magnitude faster (approximately 100x). CI alone saved 25% of CPU resources.
Both systems were written by AI.
Pando went from inception to launch in 10 weeks. The core design was created by a single engineer, while the code was primarily written by agents driven by Codex. Several engineers handled deployment, and the system began serving production traffic in April of this year.
Scion was built by a team of seven people over five months. During the same period, the team also developed the code review tool Antique, completed six other systems, and executed the overall migration.
Anthropic initially hand-wrote a program to import Git data into Scion. They then had an early internal version of Claude Mythos Preview rewrite it, resulting in a 20x reduction in memory usage and a 4x speedup.
Anthropic engineers state that Claude now writes better code than they do. Their value lies in overseeing system design and making trade-offs—often saying "no" to Claude. Agents sometimes violate core system constraints to apply certain patterns, or add excessive defensive code for hypothetical risks.
Original Sources:
- OpenAI: Scaling Git at OpenAI https://t.co/TvB0c9mX62
- Anthropic: Redesigning source control at Anthropic https://t.co/pUtmrzacH8
- OpenAI Official Tweet: https://t.co/01sNVoCzBp
↳ Quote @OpenAIDevs (OpenAI Developers): We built Pando, a new Git backend for our monorepo, to handle more pushes and fetches without changing how our engineers and agents use Git.
Pando cut push latency by ~80% and now serves nearly a petabyte of Git data a day. We can grow Git capacity alongside agent usage.
