Codex Is Overwhelming OpenAI’s Git Infrastructure: 5 Cascading Changes Behind a Projected 2,442% Increase in Quarterly Commits

Author’s note: OpenAI has unveiled Pando, a new Git backend. With Codex driving growth, quarterly commits to its monorepo are projected to rise 2,442% compared with Q1 2024. This article traces how AI coding’s impact extends from code generation to Git, CI, and code review.

On November 2, 2026, OpenAI published a technical article titled Scaling Git at OpenAI. A chart in the article shows that quarterly commits to OpenAI’s monorepo in Q4 2026 are projected to increase 2,442% compared with Q1 2024. To handle the concurrent development load brought on by Codex, OpenAI built a new Git backend called Pando.

This isn’t a rumor or a marketing claim that “AI made code volume explode 24-fold.” The figures come from OpenAI’s official engineering blog, in an article by Aaron Friel, Taylor Blau, and Ted Nyman. Two points are worth noting upfront: 2,442% is a projection, since Q4 isn’t over yet; and the metric counts commits merged into the master branch—not lines of code, much less productivity.

What you’ll learn: By the end of this article, you’ll understand how Codex is changing the scale of software development at OpenAI through parallel tasks, why that puts pressure on Git infrastructure, and where the bottlenecks in software development are shifting.

Codex and OpenAI’s Git Infrastructure: Key Facts at a Glance

Let’s start with the facts. Everything in this table comes from OpenAI’s official disclosures; information that hasn’t been made public is clearly marked.

Quarterly Commit Growth Driven by Codex

Many reports cite the 2,442% figure on its own. The full quarterly series tells a more complete story. Using 2024 Q1 as the baseline, the table below tracks the number of commits merged into the master branch of OpenAI’s monorepo each quarter.

Three things stand out. First, growth was already underway in 2024 and 2025, so it can’t all be attributed to Codex. Second, the curve steepens significantly from +264% in 2025 Q4 to +1,378% in 2026 Q3. That acceleration aligns with the trend toward parallel agent development described by OpenAI. Third, OpenAI published only relative growth rates, not absolute commit counts for each quarter.

Another metric, measured differently, points in the same direction. On July 20, 2026, OpenAI’s developer blog noted in its introduction to Codex Code Review that the number of internal pull requests per week had more than doubled compared with the previous fourth quarter. This metric uses a different measure and time window from the quarterly commit figures, so the two can’t be added together or converted into one another. Both, however, show that code change activity is growing rapidly.

How Codex Puts Pressure on Git Infrastructure

At first glance, “AI writes code faster” sounds like it only affects individual developers. But OpenAI points to another dimension: Codex increases the number of tasks running concurrently across the entire engineering system. One engineer can have multiple agents work on unrelated features at the same time. Each agent produces branches, commits, and pushes, which then trigger a series of automated reads.

The table below maps out this chain of events based on OpenAI’s description.

An Illustrative Example of Load Amplification

Here’s a purely illustrative example to make this easier to understand. The numbers aren’t from OpenAI’s measurements. Suppose one push triggers six CI jobs, each of which fetches the code once. That means 100 pushes could result in around 600 code fetches. If agents multiply the number of pushes, the read volume grows by the same factor.

Actual request volume depends on CI caching, job reuse, and build architecture, but the direction is clear. Growth in writes is amplified on the read side, which is where Git servers first struggle to keep up. OpenAI specifically notes that the same commit may be fetched repeatedly by multiple CI jobs, research tasks, and development environments.

What Went Wrong With OpenAI’s Old Git System

OpenAI disclosed that, starting in late 2025, the systems supporting its monorepo struggled to handle growing workloads. The symptoms included slower Git fetches and pushes, failed merges, and infrastructure reliability that sometimes fell below 90%.

It’s important to understand what “below 90%” means here. It describes system reliability during some periods, but OpenAI hasn’t published the exact measurement criteria or the full time series. It doesn’t mean that “10% of the code was defective,” or that “more than 10% of OpenAI’s commits failed.”

The old architecture had two structural bottlenecks:

• Branch updates required global coordination: Many traditional distributed Git services have to maintain a consistent state across all references in a repository. Even when two agents modified completely unrelated branches, they could still compete for the same coordination path.
• Download packages were computed repeatedly: Because clients have different Git histories, the server often has to traverse objects, package them, and compress them separately for each client. When multiple agents read the same version, that expensive work gets repeated.

When human engineers were doing most of the work, these issues were manageable. But once large numbers of agents and CI jobs started running concurrently, they became system bottlenecks.

How Pando Responds to Git Pressure from Codex

OpenAI hasn’t abandoned Git. Pando still uses the standard Git protocol and clients, so engineers’ existing commands and workflows remain largely unchanged. What changed is how the server stores data, updates references, and delivers data. The table below compares the key differences between the old approach and Pando.

Pando’s Two Core Ideas

First, concurrent writes. Pando gives up maintaining a single, point-in-time consistent snapshot of the entire repository. Instead, each branch maintains its own version. Pushes to different branches can run in parallel, and only requests modifying the same Ref need conflict resolution. The trade-off is that, when reading multiple branches at once, a client may see branches from different points in time. OpenAI considers this an appropriate trade-off for its use case.

Second, reuse on reads. Pando stores the Packfile received with each Push as immutable data in a Blob Store. When another client performs a Fetch, the server selects existing Packfiles to deliver based on the Commits the client already has and wants, rather than repackaging the data. In the background, it also merges many small Packfiles into larger collections in layers, so clients that haven’t updated in a long time don’t have to download too many files.

OpenAI’s production figures include a nearly 80% drop in median Push latency, close to 1 PB of Git data delivered per day, and a peak hourly Packfile delivery volume of more than 57 TB. Note that 1 PB is the amount delivered: repeated reads of the same data count toward it, so it doesn’t mean 1 PB of new code is produced each day.

Pando itself was also developed with Agent involvement. OpenAI says one engineer designed its core architecture, multiple Agent teams helped implement it, and Git compatibility test suites and deterministic simulation tests were used for validation. The company hasn’t claimed that AI wrote all the code, though.

The Impact of AI Coding: The Bottleneck Is Shifting Away from Writing Code

What This Means for Developers and Teams

The most interesting part of Pando’s story isn’t that OpenAI built its own Git backend. It’s the pattern the story reveals: AI coding lowers the cost of generating code, shifting pressure downstream along the engineering workflow. Git is just the first place that pressure has surfaced. Code review, testing, and integration are feeling it too.

In its article on Codex Code Review, OpenAI acknowledges that more and more PRs are waiting for review. Reviewers struggle to understand historical constraints and assess API compatibility risks quickly enough. Codex Code Review can read review rules defined in a repository’s AGENTS.md file to protect existing API contracts, flag logs that could expose customer data, and avoid breaking existing service integrations.

For AI development teams, this calls for a few practical changes:

• Write down review rules: Capture your team’s unwritten constraints in a rules file like AGENTS.md so AI reviews have clear guidance.
• Leave room for CI: As agents run in parallel, CI job volume may grow before staffing costs do. Assess your caching and concurrency quotas early.
• Rethink your metrics: Don’t just count commits or PRs. Track delivery lead time and change failure rate too.
• Prioritize validation: Test coverage, simulation testing, and compatibility testing determine whether you can merge agent output with confidence.

A Minimal Multi-Model AI Code Review Example

If you’d like to try a rule-based diff review workflow in your own repository, you can quickly build a prototype using an OpenAI-compatible API. The example below reads a local diff and asks a model to review it against a set of rules:

import openai, subprocess

client = openai.OpenAI(api_key="YOUR_API_KEY", base_url="https://api.apiyi.com/v1")
diff = subprocess.run(["git", "diff", "HEAD~1"], capture_output=True, text=True).stdout

resp = client.chat.completions.create(
    model="YOUR_MODEL",  # Replace with a coding model available on the platform
    messages=[{"role": "user", "content": f"请审查以下改动，重点关注 API 兼容性和日志泄露风险：\n{diff}"}],
)
print(resp.choices[0].message.content)

import subprocess
from pathlib import Path
import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1",  # Call models from multiple providers with one key
)

def load_rules(path: str = "AGENTS.md") -> str:
    """Read review rules from the repository, or return default rules if the file doesn't exist."""
    p = Path(path)
    if p.exists():
        return p.read_text(encoding="utf-8")
    return "1. 不得破坏已有 API 契约\n2. 日志中不得输出客户数据\n3. 不得破坏已有服务集成"

def get_diff(base: str = "HEAD~1") -> str:
    """Get the diff to review."""
    return subprocess.run(
        ["git", "diff", base], capture_output=True, text=True
    ).stdout

def review(diff: str, rules: str, model: str) -> str:
    """Call a model to review code changes against the rules."""
    resp = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": f"你是严格的代码审查者，请依据以下仓库规则审查：\n{rules}"},
            {"role": "user", "content": f"待审查 Diff：\n{diff}\n请逐条列出风险点和修改建议。"},
        ],
        max_tokens=1500,
    )
    return resp.choices[0].message.content

if __name__ == "__main__":
    rules, diff = load_rules(), get_diff()
    # Replace these with the model names you want to compare and see how their reviews differ
    for model in ["MODEL_A", "MODEL_B"]:
        print(f"===== {model} =====")
        print(review(diff, rules, model))

🚀 Quick-start tip: When building an AI review prototype, you can get free trial credits through APIYI at apiyi.com. Use the same API key to call OpenAI, Claude, Gemini, and other models, making it easy to compare their review quality against your repository’s rules.

Industry Impact

The New Stack reported that OpenAI was an early, heavy user of coding agents, and that the infrastructure pressures it encountered could foreshadow problems other large enterprises and code-hosting platforms may face. That’s a media assessment of a possible trend, not proof that GitHub or GitLab have already experienced the same failures.

The developer community is divided, too. Optimists believe lower coding costs will make many small projects viable that weren’t worth doing before. Skeptics point out that more commits don’t necessarily mean more valuable software: if review and testing can’t keep up, overall delivery may not be any faster. Others note that the scaling challenges of large monorepos existed long before the AI era.

Making Sense of Codex Data: Five Metrics You Shouldn’t Mix Up

One of the most common mistakes when discussing AI coding is treating different metrics as interchangeable. The table below helps clarify what each figure can—and can’t—tell you.

The Pando case shows that OpenAI’s code development workload grew significantly and its existing Git infrastructure hit a bottleneck. It doesn’t prove that software quality or developer productivity increased by the same factor, nor can it be used to estimate how many engineers Codex replaced.

Separately, OpenAI’s Harness Engineering experiment, published in February 2026, was an independent project: starting from an empty repository, it reached roughly a million lines of code and around 1,500 PRs over about five months. Those figures have nothing to do with Pando, but they reflect a similar trend: engineers are shifting their focus toward architecture, tooling, feedback loops, and code acceptance.

💡 Choosing a model: If your team is introducing coding agents, start by comparing how different models perform at code generation and review on a small scale. APIYI apiyi.com provides a unified interface for quickly switching between models, so you can evaluate them against the same test cases before choosing your primary model.

Frequently Asked Questions

Codex and Git Infrastructure Changes: Key Takeaways

• Get the metric right: 2442% is the projected growth in quarterly commits for Q4 2026, not lines of code.
• Growth accelerated sharply: The curve steepened after Q4 2025, but growth had already been underway since 2024.
• Concurrency drives the pressure: Codex increased task parallelism, and CI reads amplified the impact of increased writes.
• The old system could no longer keep up: Push and fetch operations slowed from late 2025 onward, with reliability sometimes falling below 90%.
• Pando’s approach: Independent branch writes, packfile reuse, and caching brought median push latency down by nearly 80%.
• Bottlenecks shifted downstream: Code review, testing, integration, and delivery became the new constraints.
• Getting started: Use APIYI apiyi.com and its unified interface to quickly build a multi-model review prototype.

Summary

The changes Codex brought to OpenAI come down to three things:

1. Scale: Quarterly commits in the monorepo are projected to grow 2442% compared with Q1 2024, while the number of PRs is also doubling. Code change activity has expanded dramatically.
2. Infrastructure: Parallel agents generate more branches, pushes, and CI reads, causing performance and reliability problems for the old Git backend. OpenAI built Pando in about 10 weeks to address them.
3. Engineering workflow: Writing code is no longer the slowest step. Review, testing, and delivery capacity determine whether AI coding can translate into real value.

For most teams, rather than chasing commit counts, it’s better to strengthen acceptance and review capabilities first, then gradually increase agent parallelism. If you want to quickly validate an AI review or coding agent workflow, try using the free credits at APIYI apiyi.com to compare how multiple models perform in practice.

📚 References

1. Scaling Git at OpenAI: OpenAI’s official technical article on Pando (2026-11-02)
2. Link: openai.com/index/scaling-git-at-openai

3. Notes: The primary source for the news reported here and the quarterly commit growth data

4. Custom Code Review rules for Codex: OpenAI developer blog (2026-07-20)

5. Link: developers.openai.com/blog/custom-code-review-rules-for-codex

6. Notes: The source for the doubling of weekly PRs and the AGENTS.md review rules

7. Harness engineering: OpenAI’s independent agent development experiment (2026-02-11)

8. Link: openai.com/index/harness-engineering

9. Notes: A separate case study for understanding how engineers’ roles are changing; unrelated to the Pando project

10. OpenAI Git Fork: The public repository for OpenAI’s Git client fork

11. Link: github.com/openai/git

12. Notes: See client-side improvements such as packfile-uri

13. The New Stack coverage: An external media perspective on Pando (2026-11-02)

14. Link: thenewstack.io
15. Notes: A reference for assessing industry trends

Author: APIYI Technical Team
Technical discussions: Contact us through the APIYI homepage. For more model integration resources, visit the documentation center at docs.apiyi.com.

Related Articles

• GPT-6.2 Astra Limited Rollout Revealed: 5 Signals, 3 Questions, and an Atomic Bomb on the Way?: Review the GPT-6.2 Astra phased rollout event from October 31 to November 2, 2026: timeline, five signals, three questions, evidence grading for leaks, competitor timelines, and a preparation checklist for developers.
• OpenAI releases ChatGPT usage data covering 165 categories of work activities: 5 key findings from 7 quarters and nearly 100 countries: Interpret the ChatGPT usage data for 165 work activity categories released in OpenAI Signals v3.0, clarify the statistical definition that work activities are not occupations, and analyze how changes such as rising visual design and falling programming share affect developers.
• OpenAI “Model Not Found” Error? GPT-5.5 Was Removed from ChatGPT on October 14: 5 Troubleshooting Steps and Alternatives: On October 14, 2026, GPT-5.5 was fully retired from ChatGPT, ChatGPT Work, and Codex, while the OpenAI API remained unaffected; this article reviews the latest developments as of October 15, explains the five main causes of OpenAI’s “model not found” error and how to resolve it in different scenarios, and covers alternatives including GPT-5.6 Sol, Terra, and Luna, and GPT-6 Astra.
• 3 Ways to Launch Codex CLI with Permissions Skipped: codex –yolo Is the Equivalent of Claude Code’s –dangerously-skip-permissions: In the Codex CLI, the command equivalent to Claude Code’s claude –dangerously-skip-permissions is codex –yolo; this article explains the permission differences, use cases, and security checklist for three launch methods, and provides a configuration example for connecting through APIYI.