Software infrastructure has always evolved to solve the coordination problem of its era. The first generation solved it for a single developer. The second solved it for a team. The third solved it for a distributed global workforce.

Each generation changed where coordination happens. All three assumed the same answer to who: people. AI agents have broken that assumption almost overnight, and the infrastructure hasn't caught up.

How Version Control Evolved

To understand what breaks when the assumption fails, it helps to trace how version control developed. Each generation had a flaw that the next fixed, and all three solved the same problem between the same type of actors: human developers coordinating with each other.

None of these generations questioned who does the coordinating. There was no need to. That's the assumption the fourth generation has to break.

The Accountability Gap

The scale difference between human and agent output is not incremental. A human developer makes dozens of meaningful changes to a codebase in a day. An agent fleet makes tens of thousands. GitHub's API caps at 5,000 requests per hour per token, and a fleet running under shared credentials can exhaust that in minutes.¹

~50% of code changes in AI-enabled repositories now originate from agents, a share rising quarter over quarter²

100M+ developers on GitHub, all using infrastructure built for a world where humans wrote every line³

Scale is only half the problem. The other half is provenance: where accountability lives.

For human developers, the audit trail lived in commit messages and institutional memory. Agents produce explanations only when the system is designed to capture them. When an agent makes a decision affecting production software, especially one with legal, financial, or safety consequences, you need to trace how it got there. Without that, you can't question, correct, or answer for it.

Version control used to be how developers manage changes. For agents, it's how humans stay accountable for what gets built.

A regulated company that can't explain why its software changed the way it did has a compliance problem. Explainability and auditability are enterprise requirements. Currently, no infrastructure delivers them natively.

The Sovereignty Problem

There is a second structural gap that receives far less attention: geography and control.

GitHub is U.S.-based and centralized. That creates a single point of failure for a global ecosystem, in the jurisdictional sense as much as the technical one. European financial institutions, Asian sovereign wealth funds, defense contractors, healthcare providers, and any company operating under strict data residency requirements are increasingly unwilling to build their AI infrastructure on a platform they don't control and whose legal exposure is governed by foreign law.

The demand is already written into law. The EU AI Act, Germany's BSI requirements, France's SecNumCloud framework, and equivalent regimes in Southeast Asia and the Gulf are all converging on the same requirement: critical AI infrastructure must be auditable, controllable, and ideally operable on sovereign soil.⁴ GitHub, structurally, cannot offer that. Its architecture doesn't allow it.

Open source software is global. Its primary infrastructure isn't. That gap is a large market that centralized incumbents are structurally unable to serve. Entire's network is already built for it: distributed nodes run across multiple regions and jurisdictions, users can pin repository content to the region of their choosing, and a control plane coordinates identity and access without ever becoming the central store.⁵

What the Fourth Generation Requires

Entire was built by asking what solving the core problem would require if you ignored everything about how version control is currently done.

Agents work continuously rather than in discrete commits. They mutate multiple files at once, rely on reasoning chains rather than line-by-line diffs, and operate at a frequency that makes real-time human review impossible. Making Git faster misses the point. The fourth generation has to track a different unit of work entirely.

How Entire Architecturally Breaks from Git

"Version Control for Agents." Entire is building a git-compatible database system designed to scale for the era of agents, and the first layer is now live. In July 2026, Entire opened a preview of its distributed Git network, with active regions in the US, EU, and Australia.⁵ Developers mirror an existing GitHub repository in one step. The code stays where it is, while agents clone and pull from a fast regional Entire cell that absorbs the heavy, concurrent read traffic centralized hosting cannot. In testing, the network sustained roughly 570,000 clones an hour and 586 pushes a second from a single repository, benchmarked with ForgeMark, a load-testing tool Entire open-sourced alongside the launch. Native hosting comes next. The ambition goes beyond source code: everything will be versioned. Prompts, model weights, datasets, evaluation results, reasoning traces: the full provenance chain of an AI-built system. A diff of the prompt is as important as a diff of the output it produced.

"Semantic Reasoning Layer." Intent graph over file diff. Instead of tracking file changes, Entire tracks the full graph of what the agent did, why it did it, and what it touched. The reasoning trace becomes a first-class artifact: a versioned, queryable record. This layer is already in production. The Entire CLI captures agent context into Git on every push, and now integrates with every major coding agent, including Claude Code, Codex, Cursor, Factory AI, and GitHub Copilot. Entire Blame traces any line of code back to the agent session, prompt, and decision that produced it, and code and semantic search lets developers and agents query both how the code changed and why. As Dohmke puts it: "Session logs are now the second most important artifact in software development, and they belong in the repository alongside the code."

"AI-native developer lifecycle." Entire is rethinking the developer lifecycle for an era of agents, creating an agentic assembly line. The pull request was never designed for the era of agents, and does not scale for large monorepos. Code review becomes intent review, and the first version has shipped: Entire Review sends a branch to multiple agents in parallel and returns an intent-aware review, enabling massive volumes of code to be deployed at scale.

Why We Invested

Entire is led by Thomas Dohmke, who served as CEO of GitHub and left with a precise understanding of where the architecture reaches its limits. His team, spanning Microsoft, GitHub, Atlassian, and ThoughtWorks, spent their careers close enough to the infrastructure to understand what rebuilding it from first principles requires. The insight comes from running the system at the moment those limits became visible.

This reflects a broader pattern we're seeing across the portfolio: established categories being rebuilt from first principles for the agent era. Observability, for instance, looks fundamentally different when the code being monitored was written by an agent at machine speed. Entire does the same for version control. It is a ground-up rethink of what the category is for.

GitHub built a multi-billion dollar business on top of what started as repository hosting. Entire starts from the same position, with a layer of infrastructure that didn't exist when GitHub was founded, and solves a problem GitHub's architecture cannot address. 5 months in, the thesis is off the page: the distributed network is live in preview, the semantic memory layer is integrated with every major coding agent, and the first wave of products (Blame, Review, semantic search) is in developers' hands.

The Shift Making This Urgent

The engineer who wrote the code understood it because they built it. The engineer who prompts an agent to write it needs a fundamentally different way to stay responsible for it. With agents, the writing of code is near-instant. The work moves to the front: building context, writing prompts, giving agents the knowledge they need to operate well. Humans shift from authoring and reviewing code to designing and supervising the systems that write and deploy it.

That shift is why the accountability question is so urgent, and why the infrastructure to answer it will be as foundational as Git was in 2005. The question now is who builds it. We believe Entire is the right answer.

Sources & Notes

1. GitHub REST API documentation, rate limiting section. github.com/rest/overview/rate-limits-for-the-rest-api
2. GitHub Octoverse Report 2024; internal analysis across AI-enabled repositories. Figures reflect repositories with active Copilot or third-party coding agent integration.
3. GitHub, "100 million developers," June 2023. github.blog/2023-01-25-100-million-developers
4. EU AI Act (Regulation 2024/1689), Chapter III; BSI IT-Grundschutz-Kompendium 2024; ANSSI SecNumCloud qualification requirements v3.2.
5. Entire, "An Entirely New Git Hosting Network," July 8, 2026. entire.io/blog/an-entirely-new-git-hosting-network. Benchmark figures are Entire's own testing, measured with ForgeMark (open-sourced under MIT).

‍