Can Git Actually Scale to 10,000 AI Agents?
TL;DR: OpenAI built Pando, a Git-compatible backend, because vanilla Git collapses under the concurrent write pressure of thousands of Codex agent sandboxes. If you’re already running multi-agent CI pipelines or AI coding assistants at scale, the architectural decisions inside Pando are directly relevant to how you design your repo infrastructure today — not in some hypothetical future.
At a glance
- OpenAI’s Pando system was built to support Codex, their AI coding agent, which runs in isolated sandboxes — reportedly 10,000+ simultaneously as of mid-2026.
- Standard Git’s pack-file locking mechanism breaks under more than ~500 concurrent writers on a shared monorepo, per OpenAI’s internal benchmarks cited in their engineering post (published 2026).
- Pando achieves 40× lower clone latency compared to a vanilla
git cloneon large monorepos by using virtual file system (VFS) layering that fetches objects on demand. - Microsoft’s VFS for Git (VFS4G), first shipped in 2017 for the Windows monorepo (~300 GB), is the most mature public precedent — Pando follows similar demand-paging principles.
- OpenAI’s engineering blog post “Scaling Git at OpenAI” describes object-level sharding across storage nodes and decoupled ref storage as the two core architectural pillars of Pando.
- Scalar, Git’s built-in partial-clone companion (available since Git 2.38, released October 2022), reduces initial clone size by up to 90% on large repos — the closest tool available to non-OpenAI teams today.
- In October 2026, FlipFactory’s
coderagMCP server hit reproducible Git fetch timeouts when running 120+ parallel Claude Code sessions against a shared repository — the exact failure mode Pando is designed to eliminate.
Q: Why does Git break when AI agents start writing at scale?
Git was designed for humans — developers who commit a few dozen times a day at most. The moment you introduce AI agents that can each open a branch, write code, run tests, and push — potentially hundreds of times per hour — you slam into Git’s fundamental concurrency model.
The core problem is ref storage and pack-file locking. In standard Git, when two processes try to update refs or repack objects simultaneously, one blocks. On a busy monorepo with hundreds of agents, this serializes what should be parallel work.
We ran into this directly in October 2026 at FlipFactory. Our coderag MCP server — which indexes and retrieves code context for Claude Code sessions — was configured to pull fresh repo state before each retrieval cycle. At around 120 concurrent Claude Code sessions, fetch operations started timing out at the 30-second mark. PM2 logs showed git fetch processes stacking up, each waiting on the previous pack operation to release its lock. Dropping to shallow clones (--depth=1) bought us headroom, but it wasn’t a fix — it was a workaround. The problem isn’t bandwidth. It’s the serialized locking architecture inside Git itself.
Q: What exactly did OpenAI change to make Pando work?
OpenAI’s “Scaling Git at OpenAI” post identifies three architectural shifts that separate Pando from standard Git hosting:
1. Object-level sharding. Instead of storing all pack files on a single server, Pando distributes Git objects across storage shards. This eliminates the single-node bottleneck for object reads, which dominate during clone and fetch operations.
2. Decoupled ref storage. Refs (branches, tags, HEAD pointers) are stored separately from objects in a purpose-built, highly consistent store — not in the flat-file .git/refs/ structure. This removes the locking contention on ref updates that kills concurrent agents.
3. Virtual file system layering. Sandboxes don’t receive a full clone upfront. They get a virtual filesystem that fetches objects on demand — meaning an agent working on a single module never pays the cost of cloning the entire monorepo.
What’s notable is that none of these ideas are entirely novel. They’re the same principles Microsoft applied to VFS4G for the Windows codebase. What OpenAI had to do was implement them at a different axis of scale: not one massive monorepo accessed by thousands of human developers, but potentially millions of short-lived agent sessions each needing isolated, writable views of code.
In our FlipFactory setup, moving our coderag MCP to use --filter=blob:none partial clones (available since Git 2.22) reduced cold-clone time from 47 seconds to 9 seconds for our primary TypeScript monorepo — a meaningful step toward the demand-paging model Pando implements fully.
Q: What should a dev team running AI coding agents do right now?
The honest answer is: Pando isn’t available to you. It’s an internal OpenAI system. But the architectural lessons are directly actionable with tools you can deploy today.
Immediate wins (no infrastructure rebuild required):
- Switch all agent-initiated clones to
git clone --filter=blob:none --depth=1. We measured this cutting clone time by 5× on average across FlipFactory’s CI agent pipelines in September 2026. - Run Scalar (
git scalar register) on your monorepos. It enables partial clone, background maintenance, and file system monitor — the closest public approximation to Pando’s demand-paging. - Isolate agent workspaces to per-session ephemeral repos (fork or worktree per agent). This eliminates ref contention entirely at the cost of storage overhead.
Medium-term (if you’re scaling past ~200 concurrent agents):
- Evaluate Gitea with its built-in object storage backend (S3-compatible) for sharding — not Pando, but removes the single-disk bottleneck.
- Consider virtual repo views via proxy layers like
git-http-backendwith custom middleware that serves filtered packs per agent context.
At FlipFactory we’re currently using our coderag and knowledge MCP servers together — coderag handles code retrieval while knowledge maintains agent session state — to reduce the number of full repo fetches each agent needs. It’s not Pando. But it cuts our Git server load by roughly 60% compared to naive per-request full fetches, based on PM2 metrics from our production cluster as of October 2026.
Deep dive: The monorepo scaling problem has a longer history than Codex
OpenAI is not the first organization to discover that Git doesn’t scale. They’re the first to encounter the problem from the AI agent concurrency angle — but the underlying physics of Git’s design have been colliding with large engineering organizations for over a decade.
Microsoft’s VFS for Git (initially called GVFS, now VFS4G) was the first major public solution to the monorepo scale problem. When the Windows team moved to Git in 2017, they were dealing with a repository that weighed in at approximately 300 GB and was touched by thousands of engineers daily. According to Microsoft’s engineering blog post “The largest Git repo on the planet” (published on the Azure DevOps blog, 2017), a standard git checkout on the Windows repo took 3+ hours. VFS4G reduced that to under 5 minutes by virtualizing the working directory and fetching blobs on demand — precisely the technique Pando uses for agent sandboxes.
Google’s Piper took a different approach entirely: they abandoned Git’s distributed model and built a centralized version control system purpose-built for monorepo scale. Described in Potvin and Levenberg’s “Why Google Stores Billions of Lines of Code in a Single Repository” (Communications of the ACM, 2016), Piper serves roughly 25,000 engineers making ~45,000 commits per day — numbers that make even OpenAI’s Codex workload look modest. Google’s lesson was that Git’s distributed design, while excellent for open-source collaboration, creates fundamental scaling ceilings in centralized enterprise environments.
What makes OpenAI’s Pando architecturally interesting is that it tries to preserve Git compatibility — agents and developers interact with standard Git clients — while replacing the backend entirely. This is the right call for developer experience. Asking 10,000 AI agents to learn a new VCS protocol is not a viable path.
The deeper question for the industry is whether Git-compatible backends like Pando will eventually become the standard infrastructure layer for AI-assisted development, the same way object storage replaced local disk for application data. Tools like Scalar (Microsoft, now part of core Git), libgit2-based custom backends, and emerging commercial offerings suggest the ecosystem is already moving in that direction.
For teams building on top of AI coding agents today — using Claude Code, Cursor, or similar tools — the architectural gap between “Git works fine” and “Git is your bottleneck” is measured in concurrent agent count, not time. Based on our production numbers at FlipFactory (and corroborated by OpenAI’s published findings), that wall appears somewhere between 100 and 500 concurrent writers on a shared repository. If your agent usage is growing, you’ll hit it. Planning for it now — through partial clones, ephemeral workspaces, and sharded object storage — is considerably cheaper than refactoring under pressure.
Key takeaways
- OpenAI’s Pando handles 10,000+ Codex sandboxes via object sharding and decoupled ref storage — not available publicly as of November 2026.
- Standard Git ref locking fails at roughly 500 concurrent agent writers on a shared monorepo, per OpenAI’s published data.
- Microsoft’s VFS4G (2017) and Google’s Piper (documented 2016, CACM) are the two foundational precedents Pando builds on.
--filter=blob:none --depth=1cuts agent clone time by 5× — the fastest zero-infrastructure-change improvement available today.- FlipFactory’s
coderag+knowledgeMCP stack reduced Git server load by 60% in production as of October 2026.
FAQ
Q: Can I use Scalar today to approximate what Pando does for agent workloads?
Scalar (git scalar register) is the most accessible step toward Pando-style demand-paging. It enables partial clone, background repacking, and filesystem monitoring out of the box with Git 2.38+. It won’t solve ref contention at 1,000+ concurrent writers — but for teams running 50–200 parallel AI agent sessions, it meaningfully reduces clone time and background maintenance overhead. We registered our primary monorepo with Scalar in August 2026 and measured a 3.2× reduction in agent cold-start time during CI runs.
Q: Do I need to move to a monorepo to hit these scaling problems?
No. The contention issues Pando solves appear in any scenario where many agents share a single repository — monorepo or otherwise. If 300 Claude Code agents are all working in the same microservice repo, you’ll hit pack-file locking the same way you would in a monorepo. The solution set is the same: ephemeral per-agent workspaces, partial clones, or a backend that decouples object storage from ref management. Repo architecture (mono vs. multi) affects which repos hit the wall, not whether the wall exists.
Q: How does this affect teams using platforms like GitHub or GitLab rather than self-hosted Git?
GitHub and GitLab both run custom Git backends that handle more concurrency than vanilla git-daemon. GitHub’s backend (based on Gitaly at GitLab, proprietary at GitHub) does handle some level of concurrent access better than raw Git. However, neither is designed for the 10,000-concurrent-agent scenario Pando targets. If you’re running large-scale AI agent pipelines against GitHub-hosted repos today, the practical mitigation is the same: shallow clones, sparse checkout, and limiting how frequently agents fetch from origin.
About the author
Sergii Muliarchuk — founder of FlipFactory. Building production AI systems for fintech, e-commerce, and SaaS clients. We run 12+ MCP servers, n8n workflows, and FrontDeskPilot voice agents in production.
We’ve operated coderag, knowledge, transform, and utils MCP servers under real concurrent Claude Code load — which means Git infrastructure isn’t a theoretical concern for us, it’s a production constraint we’re actively engineering around.