How Version Control Will Evolve for the Agent Boom

It's been over twenty years since developers started adopting Git. It's by far the most popular version control system today. And, it will be around for another 20 years to come. The question is not if Git survives through the sheer weight of its ecosystem lock-in. The question is how we can expand, rewire, and evolve Git hosting for a world where AI agents are the primary producers of code.

Capturing the Soul of Software

Git captures what was written in plain text files in a repository. In simple terms, it stores lines of code with commit messages, creating a record of what changed over time. But as code becomes increasingly abundant through agents, the context behind "why" the code was written is becoming vital: the agent sessions with their prompts, tool calls, checkpoints, and decisions. They all reveal the intent of the developer and tell the story of how a piece of software was built.

Our hypothesis is simple: session logs are now the most important artifact in software development, and should be stored alongside the code itself in the repository. With this semantic memory layer, agents can stop repeating mistakes, which enables higher accuracy, increases productivity, and decreases token spend. And humans can more easily understand and verify what was built and why, providing a provenance layer that leads to far faster review periods.

With this new semantic layer preserved in the repository, groups of humans and fleets of agents can collaborate and build together in parallel without overwriting, colliding, or losing understanding.

Returning Git to Its Original Promise

By design, Git was always meant to be decentralized. Every clone contains a complete copy of the repository and its history, allowing software to be replicated across many hosts rather than controlled by a single server. But in practice, Git hosting platforms have largely routed developers into centralized systems. This was sustainable until agents came along.

In a world where large fleets of agents are coding with incredible speed and parallelization, continuing to route everything through such centralized platforms will lead to rate limiting, outages, slower agents, and a fundamentally constrained software development lifecycle. Git hosting must evolve to meet its original promise: a distributed network of many hosts, not a system where the world's software is stored in a single location. Repositories should exist in as many places as possible, allowing for not only higher availability and resilience, but also enabling agents to query, synchronize, and operate against them at massive scale and more local, resilient, and scalable access patterns.

This also provides the clear benefit of digital sovereignty. With a decentralized architecture, developers and organizations can host, replicate, and store their code with data residency in-region while still participating in a broader, globally distributed collaborative network.

Orchestra of Agents

Agents have become the new coders, and with this shift, software developers will need deeper engineering judgment than ever before. Our role is now to stream our ideas into an orchestra of agents that needs to be kept in sync. In these new software development loops, Git will remain the source of truth for code. It will capture provenance, coordinate agent work, and operate across a decentralized network. With that, we will create platforms that truly enable agents and humans to collaborate, build, and ship software around the clock at machine speed.