OpenAI Builds Pando and Acquires Pierre as AI Agents Outgrow Developer Infrastructure

Back-to-back GitHub outages on November 3 and 4 disrupted Git operations, pull requests, issues, Actions, and Webhooks across the platform — the latest in a streak of 201 incidents over the past twelve months. The timing arrived at a pointed moment. Two days before the first outage, OpenAI had disclosed Pando, an internal Git backend rebuilt from scratch because its coding agent had made ordinary push operations unreliable. Two days after, OpenAI announced it would acquire Pierre Computer Company, whose infrastructure already runs inside Codex. Taken together, the moves mark a structural inflection in developer tooling: the infrastructure that hosted human-written code for two decades is being fundamentally redesigned for a world where AI agents write most of it.

The November announcements join a broader pattern that has been forming since October. Anthropic published details of Scion, a custom version control system that fully replaces Git in its monorepo, on October 13. Cursor launched Origin, a code hosting platform embedded inside its AI editor, on August 17 — the same day GitHub went down for seven hours and 35 minutes. Each company arrived at a structurally similar conclusion through its own engineering experience: Git was not built for the scale and concurrency that agentic coding creates.

Codex Grew Commits Faster Than Git Could Handle

The proximate cause of Pando was not GitHub's reliability but OpenAI's own coding agent. When developers began running multiple parallel Codex sessions, the pattern of pushes changed: instead of a single sequential commit, one engineer might have several background agents pushing changes simultaneously, each triggering automated review and test pipelines. OpenAI reported in its November 2 engineering post that push latency degraded under these conditions, merges failed intermittently, and overall system reliability fell below acceptable levels.

Pando's response was architectural rather than a simple capacity increase. The core innovation is per-branch parallel updates: each branch is updated independently, so pushes to unrelated branches proceed concurrently instead of competing for the single repository-wide write lock that Git's reference update model requires. Incoming packfiles go directly to blob storage while branch versions and their dependencies are tracked in a separate metadata service the team calls Turtle. A delivery service called Express maximizes pack reuse across clients, achieving a cache hit rate above 99 percent.

The performance numbers OpenAI reports are substantial, though company-benchmarked without independent reproduction: median push latency fell by nearly 80 percent, the system processes close to one petabyte of Git data per day, and it has served more than 57 terabytes of compressed Git packs in a single hour. That throughput runs on a small number of CPU cores, made possible by the high cache hit rate.

Pando was itself built using Codex. One engineer designed the core architecture; teams of agents implemented it; a small group of engineers deployed it. The process moved from kickoff to production in approximately ten weeks, with live traffic since April 2026. It is written in Rust with no legacy dependencies and uses formal verification tools — Lean for proof-checking and TLA+ for specifying concurrent system behavior — to validate correctness properties. Agents also run continuously to probe Pando's security posture. OpenAI has contributed fixes back to the upstream Git project and says it is exploring ways to make Pando available more broadly, but the system itself remains internal.

One deliberate trade-off worth noting: Pando lacks a single point-in-time view across the full repository. Each branch is internally consistent, but clients reading across branches simultaneously may see different temporal snapshots — manageable for human review workflows, but requiring consideration in agent pipelines that pull from multiple branches at once.

Pierre Acquisition Closes the Missing Hosting Layer in Codex

On November 4, two days after the Pando post appeared, OpenAI announced its intent to acquire Pierre Computer Company, Inc. Financial terms were not disclosed; the transaction remains subject to regulatory approval. Pierre's open-source projects — Diffs, Trees, and DiffsHub — will remain open source after the acquisition closes.

The deal is not speculative. Pierre's Trees library allows users to browse files in a repository; its Diffs library renders side-by-side code comparisons. Both are already embedded in the Codex application. Any developer who has browsed files or reviewed a change inside Codex has already been using Pierre's code. What the acquisition adds is Code Storage: programmable, managed Git infrastructure calibrated for the throughput and parallelism that AI agents generate rather than the cadence of human development teams.

Code Storage's customer list gives the clearest picture of the scale problem Pierre was designed for. Lovable, an AI-driven development platform, creates more than 8 million new repositories every week, with peaks reaching 250 repository creations per second. Pierre's specifications are built around this environment: individual repositories up to 32 terabytes, more than 500 Git requests per second per repository, over 15,000 API requests per second across the platform, and a 99.99 percent availability commitment. The team behind it comes from Cloudflare, Coinbase, Discord, GitHub, Meta, Reddit, Stripe, and Twitter.

The acquisition fits a recognizable platform consolidation pattern. Axios, which broke the story, framed it as OpenAI targeting Microsoft's GitHub. The framing is directional if premature: Pando addresses the backend transport layer; Code Storage addresses managed hosting; Codex is the agent layer on top. The three moves in five days — Pando disclosure, GitHub outages, Pierre acquisition, expanded Codex quotas — look like a coordinated platform play rather than coincidence. What OpenAI still lacks publicly is a code review and collaboration layer; that gap remains.

The competitive significance for Microsoft is unusually direct: the company owns GitHub while also holding a substantial investment stake in OpenAI, making it simultaneously backer and competitive target of the same organization.

Anthropic Went Further: Seven Engineers Replaced Git Entirely

Where OpenAI upgraded its Git infrastructure while maintaining protocol compatibility, Anthropic discarded Git altogether. On October 13, the company published an engineering post describing Scion, the custom version control system its monorepo runs on today. A team of seven engineers completed the full migration from Git in five months while merge volume more than doubled, then doubled again.

The scale numbers that made Git inadequate are specific. In May 2026, Anthropic's monorepo processed roughly 2,500 code merges per day. By September, that figure exceeded 30,000 — a 12-fold increase in four months. Continuous integration was fetching the repository approximately 25 million times per day. At the peak of the Git-based system, the company maintained hundreds of mirrors to distribute that read load, with each checkout consuming several minutes of CI time. The main branch history had grown to nearly 100 gigabytes. If those CI fetches had accessed the repository naively under Git, total daily data transfer would have exceeded 600 petabytes.

Scion's design responds to these constraints at the architectural level. Git's distribution model assumes clients may need to work offline and therefore gives each client a complete repository copy — a deliberate design choice from Git's origins in 2005. Scion treats clients as permanently connected and pushes all computation to the server: commits, merges, rebases, history queries, and line-level change attribution all run server-side. The client fetches lazily, retrieving only the specific files or changesets a given task requires, without maintaining a full local copy. The fundamental unit of history is the changeset: an entry in a write-ahead log that records only the modified files relative to its parent node, with content-addressed pointers to compressed file contents in object storage.

The operational improvements Anthropic reports, though company-benchmarked, are plausible given the elimination of hundreds of Git mirrors: Scion's infrastructure is 200 times smaller in CPU and memory than the previous mirroring system, and checkouts are approximately 100 times faster. The seven engineers also built companion tooling: Antique, the code review interface; a code search system; and an IAM layer for access control. The analogue Anthropic points to is Google's Piper, the centralized monorepo system that powers internal development at Google and which similarly treats the repository as a server-side resource rather than a distributed copy.

Claude is woven through Scion's construction and ongoing operation. When Claude Mythos Preview became available internally, Anthropic had the model rewrite the Git-to-Scion ingestion pipeline. The result consumed 20 times less memory and ran four times as fast. Claude also participates continuously in the code review process itself through what Anthropic calls adversarial review: Claude acts as a hostile critic of proposed changes, running browser-based tests that produce screenshots and operation recordings as verifiable evidence before human engineers assess the results. The practical effect is that every change entering Anthropic's codebase passes through a Claude evaluation before a human sees it.

Scion will not become a general-purpose product. Anthropic explicitly describes it as "by no means a suitable replacement for git for general use," because its centralized architecture would require extensive migration work from any organization not already operating at Anthropic's specific scale. What the company does predict is that most engineering organizations running active AI coding programs will encounter similar Git bottlenecks within six to twelve months as agent commit volumes compound.

Origin, GitHub, and the Race to Rebuild at Scale

Cursor entered this space from a product angle. SpaceX acquired Cursor via its parent company Anysphere in a $60 billion all-stock deal that closed August 14. Three days later, Cursor launched Origin, a code hosting platform embedded directly in the editor — on the same day a seven-hour-and-35-minute GitHub outage took down Git operations, Actions, pull requests, issues, and Webhooks. The company described it as "designed for agent scale."

Origin is Git-based with repository URLs at cursor.com/codebase/name and optional GitHub synchronization for teams preferring a phased migration. Cursor had acquired Graphite — a pull request workflow startup — in December 2025, giving Origin a code review foundation before launch. By October, the marketplace had expanded to more than 20 integrations including Vercel, Depot, Buildkite, Cloudflare, Linear, Sentry, and CodeRabbit.

GitHub's response operates at a different scale. At GitHub Universe on October 28, the company disclosed adding 4 million CPU cores, 160 petabytes of storage, and 50 terabits per second of network capacity during 2026 alone. Monthly commit volume went from 65 million in 2024 to 7.4 billion in September 2026 — roughly 100-fold in under two years, driven primarily by AI coding tools. GitHub Actions processed 3.26 billion jobs in September alone.

GitHub is also pursuing architectural changes rather than capacity alone. Its internal benchmarks show up to 35 times higher write throughput with a redesigned architecture that separates compute from storage. Parallel branch updates — the same design principle at the core of Pando — are being implemented to prevent agents committing to different branches from blocking each other at a shared write layer. A multi-region migration to Azure is expected to complete in early 2027. The November 3 and 4 outages suggest the transition remains incomplete.

Three Theories, One Problem, No Public Solution Yet

The pattern across all four actors is structurally the same: AI coding agents changed the relationship between developers and the systems that store their work in ways that existing infrastructure was not designed to handle. Human engineers push code in linear sequences across a working day, with natural pauses built in. Agents push code continuously, in parallel, across many branches simultaneously, without pauses. Git's core design — per-repository write locks, full-clone client architecture, and human-paced merge queues — was built for the first pattern and scales poorly for the second.

The three architectural responses now in production illustrate distinct theories. Anthropic centralized everything: Scion puts all computation on the server and reduces client requirements to nearly nothing. OpenAI parallelized at the branch level while keeping Git compatibility: Pando removes the shared write lock without breaking the existing tooling ecosystem. Cursor embedded hosting inside the development environment: Origin collapses the boundary between where code is written and where it is stored.

None of these answers are yet publicly available to the broader software industry. Scion is internal and not planned for release. Pando is internal with no announced availability date. Code Storage, the only component moving toward general deployment via the Pierre acquisition, addresses managed hosting but not the underlying protocol constraints. GitHub's implicit thesis — that capacity investment and architectural evolution can solve the agent-scale problem without replacing Git — will face a real test over the next year. Anthropic's prediction is explicit: six to twelve months before most organizations running serious AI coding programs hit the same wall. That clock, more than any product announcement, is what makes the developer infrastructure question urgent now.