The Custody of Code: Why Source Control Became the Most Contested Layer in AI

For most of the last three years, the fight over AI in software development happened inside the editor. Whichever tool put the smartest autocomplete next to your cursor — Copilot, then Cursor, then a dozen others — was assumed to be winning. The editor was where the magic was visible, so the editor was where attention went. That framing is now obsolete, and the events of a single afternoon in June 2026 are the clearest evidence yet.

On June 16, at its first developer conference, Cursor's maker did three things at once. It launched Origin, a git hosting platform built explicitly for AI agents rather than human developers. It shipped a mobile app for supervising those agents from a phone. And it confirmed it was training a frontier model from scratch on a supercomputer. On the same afternoon, SpaceX formally confirmed it would acquire the company — Anysphere, Cursor's parent — in an all-stock deal valued at roughly $60 billion, the largest acquisition of a venture-backed startup on record.

The editor was the smallest part of that announcement. The important part was the quiet expansion downward — out of the editor and into the place where code is reviewed, stored, and made canonical. That is the move that matters, because it reveals what the AI coding companies have actually been building toward. Not a better autocomplete. Control of the entire development pipeline, from the keypress to the commit to the source of truth. This is the custody of code, and it is becoming the most contested layer in the industry.

The Deal, and What Came With It

It is worth being precise about the facts, because the scale is easy to wave past.

Read those four numbers together and a strategy emerges that no single one of them shows alone. A company with four million developers and four billion dollars of revenue, now backed by one of the largest private compute fleets in the world, training its own frontier model, and — crucially — launching its own git host. The editor was the wedge. The pipeline is the business.

When Origin ships in the fall of 2026, Cursor will own all three layers of the loop that produces software: the surface where agents write code, the layer where batched changes are reviewed, and the host where the canonical repository lives. No prior developer-tools company has held all three at once. GitHub had the host and the review layer but never the editor. JetBrains and Microsoft had editors but not the host. The integration Cursor is assembling is new, and it changes the shape of the market.

From Editor Wars to Pipeline Wars

The reason the editor got all the early attention is that it was where the capability was legible. You could watch a model write a function. You could feel the productivity. But editors are also the least defensible layer of the stack, for a simple reason: they are cheap to switch. A developer can move from one AI editor to another in an afternoon, carrying their habits with them, because the editor holds almost no state that the developer cannot walk away from.

Once you see the stack this way, the strategic logic of every recent move snaps into focus. The editor was never the prize. It was the customer-acquisition channel for the layers underneath it — the layers that hold state, accumulate data gravity, and are expensive to leave. The company that started at the cursor is now reaching all the way down to the commit, and the further down it reaches, the harder it becomes to dislodge.

The chart is directional, not measured, but the ordering is the point. Value and defensibility increase as you descend toward the repository. The editor is where users notice you; the host is where they cannot leave you. Strategically, the editor wars were a skirmish to decide who got to start the pipeline-integration race. That race is now on, and it is being run downward.

Why the Repository Is the Prize

To understand why source control specifically became the contested layer, you have to understand what the repository has quietly become in an agentic workflow. For human developers, the repository is storage with history — a place to keep code and a record of how it changed. For AI agents, the repository is something more fundamental: it is the agent's memory, its context, and its ground truth all at once.

An agent that is asked to implement a feature does not hold the codebase in its head. It reads the repository to understand the system, plans against what it finds, makes changes, and writes them back. The repository is the substrate the agent reasons over. Whoever controls that substrate controls the context the agent sees, the speed at which it can retrieve relevant code, and the format in which changes are proposed and merged. That is an enormously powerful position, and it is invisible if you are still thinking of git as a backup system.

This is also why the data gravity is so severe. A codebase is the single most expensive artifact an engineering organization owns to move. It is entangled with CI pipelines, with deployment, with issue tracking, with access control, with years of commit history that encodes institutional knowledge. Migrating a repository host is not like switching editors. It is closer to relocating a factory. The vendor that holds your repository holds the heaviest object in your toolchain — and if that same vendor also owns your editor, your review layer, and your model, the object only gets heavier with every commit.

There is a second-order effect that makes the repository even more valuable in the agent era: the host that sees every change an agent makes accumulates the most valuable training and evaluation data in software — paired records of intent, proposed change, human judgment, and outcome. I have written before about how AI procurement is collapsing into a few all-encompassing vendor relationships in the structure of universal-credit AI deals, and source control is the same dynamic arriving in the developer's daily tools: the data the host sees feeds the model, and the better model deepens the reason to stay on the host.

What "Agent-Native" Source Control Actually Means

The phrase "a git host built for agents rather than humans" sounds like marketing, but it describes a real and consequential redesign. The primitives of git as we have used it for fifteen years — the branch, the commit, the pull request — were designed around how humans collaborate. They assume a person opens a branch, makes a focused set of changes, and asks other people to review them. Agents do not work that way, and a host designed for agents reflects that difference everywhere.

The review layer is where this gets most interesting and most contentious. In the human model, the pull request is a social object: it is how a team teaches itself, catches mistakes, and shares context. An agent-native host replaces the human diff-reading ritual with an automated evaluation surface that batches, summarizes, and scores changes before — or instead of — a person looking at them. That is a genuine efficiency gain when agents are producing more code than humans can read. It is also a quiet transfer of judgment from the team to the platform, and the terms of that transfer are written by whoever owns the host.

When the majority of changes flowing into a repository originate from agents — and on the most aggressive teams that crossover has already happened — the design of the host stops being a back-office detail. It becomes the throttle on how fast and how safely software can be produced, and the company that designed the throttle is in a position of structural power over every team that depends on it.

The Three-Way Board

Cursor is not doing this alone, and the most important context for the SpaceX deal is that it is one move in a board-wide consolidation. Three of the largest forces in technology are now assembling the same vertically integrated coding stack, each from a different starting point.

Each of the three is converging on the same end state from a different edge of the stack. OpenAI started with the model and bought its way up into the editor. Microsoft started with the editor and the host and is pushing the model and the agent into the center. Cursor started with the editor and is reaching down to the host while training its own model. The starting points differ; the destination is identical — one company owning editor, review, host, and model as a single integrated product.

The shares are illustrative, but the structure they describe is real: a market that was a broad ecosystem of interoperable tools two years ago is contracting into a small number of vertically integrated estates. The competitive question has shifted from "which tool has the best autocomplete" to "whose estate does your engineering organization live inside." That is a far more consequential question, and far harder to answer your way out of once you have picked.

The Lock-In Is in the Pipeline, Not the Editor

The conventional worry about AI coding tools has been about the editor: am I getting locked into one vendor's autocomplete? That worry was always misplaced, because the editor is the one layer you can actually leave. The real lock-in compounds in the layers below, and it compounds in ways that are easy to underestimate until you try to unwind them.

That last surface — model entanglement — is genuinely new. In the pre-AI era, switching source-control hosts was painful but bounded: you moved the bits, you re-wired CI, you trained the team on new buttons. The code itself behaved the same on the other side. When the host vendor also owns the model and tunes it on your repository's history, leaving the host means leaving behind a model that has learned how your codebase works. There is no migration script for that. It is a switching cost that did not exist before, and it is the deepest hook in the new stack.

This is the same lock-in logic that has played out in cloud and in enterprise software for decades, arriving now in the developer's most intimate tools. The difference is the speed at which it forms. Because agents write so much of the code, and because the host sees every change, the data gravity and the model entanglement accumulate in months rather than years. A team that adopts an integrated estate in the spring can find itself structurally committed to it by the fall, before anyone made a deliberate decision to commit.

The Custody Problem

There is a sharper word than "lock-in" for what is happening, and it is custody. When your editor, your review layer, your repository, and your model all belong to one company, that company has custody of your code in a way no single vendor ever had before. Custody is not just about whether you can leave. It is about who can see, who can change, who is accountable when something goes wrong, and whose infrastructure your most sensitive asset depends on to function day to day.

The reliability dimension of custody became concrete this spring. The incumbent host's infrastructure has been visibly strained under the new load that agentic workflows put on it.

When the repository is passive storage, an hour of host downtime is an annoyance. When the repository is the working memory that every agent on the team reads from on every task, host downtime halts the pipeline. Custody concentrates that risk: the more of the stack one vendor holds, the more of your engineering capacity depends on that single vendor staying up, staying solvent, and staying aligned with your interests.

Then there is the question that should give every engineering leader pause: whose model, on whose compute, is now reading your proprietary codebase to do its job? In the Cursor case, the answer involves the same compute fleet operated by a company with sprawling interests far beyond developer tools. In the OpenAI case, acquired editor users had their code brought under the model company's data policies. These are not hypothetical concerns. They are the predictable consequence of letting one company hold custody of code, and they deserve the same scrutiny that observability now gets — the discipline I covered in instrumenting AI agents with OpenTelemetry tracing applies just as much to knowing what the agent did to your repository as to knowing what it cost.

The Economics That Justify $60 Billion

A $60 billion price for a company with roughly $4 billion in revenue is a fifteen-times-revenue multiple, which looks aggressive until you account for what the buyer is actually purchasing. It is not buying this year's revenue. It is buying a position in the pipeline, and the lifetime value of a customer who lives inside an integrated estate is structurally different from the lifetime value of a customer who merely rents an editor.

The mechanics are familiar from cloud computing. The first dollar a customer spends is the cheapest to win and the easiest to lose. Each subsequent dollar — the repository migrated in, the CI wired up, the team trained, the model tuned — raises the wall around that customer a little higher. By the time an organization has run a year of agentic development on an integrated estate, the cost of leaving has grown so large that renewal is no longer really a decision; it is the path of least resistance. The multiple is a bet that the pipeline converts millions of volatile editor subscriptions into millions of sticky estate tenancies.

The widening gap between the two lines is the entire investment thesis in one shape. An editor-only relationship decays as competitors improve; an estate relationship compounds as data gravity and model entanglement accumulate. SpaceX is not paying fifteen times last year's revenue. It is paying for the area between those two curves, integrated over the next decade, across four million developers.

How the Incumbents Answer

Cursor is not operating in a vacuum, and the most telling part of this moment is how differently the established players are positioned to respond. Each has a piece of the pipeline and a gap, and the gaps determine the strategy.

The most interesting near-term tension is OpenAI's missing host. A company that owns a frontier model and a popular editor but not the repository is holding two of the three pipeline layers, and the structural logic that pushed Cursor toward Origin pushes OpenAI toward a host of its own. The pattern is too consistent to be coincidence: every player with two layers is reaching for the third. That is what makes this a board-wide consolidation rather than a single dramatic deal — the incentives point everyone at the same prize.

GitLab and the independent hosts occupy the most strategically interesting position of all, because the consolidation creates demand for exactly what they offer. As the integrated estates raise the custody stakes, a neutral, portable, self-hostable repository stops being the boring default and becomes a deliberate hedge. The independents will not win the developers chasing the smoothest integration. They will win the engineering leaders who have read the fine print on custody and decided to keep an escape hatch open — a smaller market, but a durable and increasingly self-aware one.

The Precedent: Toolchains Bundle, Unbundle, and Bundle Again

None of this is unprecedented. The history of developer tooling is a long oscillation between bundling and unbundling, and knowing which phase you are in tells you a great deal about what comes next.

In the 1990s, the integrated development environment bundled the editor, the compiler, the debugger, and the build system into one product, because that integration made individual developers dramatically more productive. The web era then unbundled the toolchain into a sprawling marketplace — a separate editor, a separate host, a separate CI service, a separate package registry — connected by open protocols and APIs, because interoperability and choice mattered more than tight integration when humans were doing the integrating in their heads.

Agentic development is now forcing the pendulum back toward the bundle, and the reason is mechanical rather than fashionable. An agent that has to reason across an editor, a host, a CI system, and a model stitched together by APIs is slower, more error-prone, and harder to supervise than an agent operating inside one integrated estate where those layers share a data model. Integration is not just a business strategy here; it is a genuine engineering advantage for the agent. That is what makes this bundle harder to resist than past ones — the integration that creates the lock-in also makes the product measurably better. The teams that adopt it will not be making a mistake. They will be making a trade, and the job is to make it consciously.

The Antitrust Question Nobody Is Asking Yet

There is a regulatory dimension to all of this that has been almost entirely absent from the conversation, and it will not stay absent. A single company coming to own the editor, the review layer, the repository, and the model for a meaningful fraction of the world's professional developers is a concentration of control over software production that has no real precedent.

The deal requires regulatory approval, and the conventional analysis will ask whether the combined entity reduces competition in some defined market — code editors, say, or git hosting. But that framing misses the structural issue. The concern is not that one company will have too large a share of any single layer. It is that a handful of companies will each own an entire vertical pipeline, and that software production — an activity that underpins essentially every other industry — will run inside a small number of private, integrated estates whose terms, reliability, and data practices are set unilaterally.

Whether regulators develop a framework for pipeline concentration, as opposed to single-market concentration, is one of the more consequential open questions of the next two years. The outcome will shape not just who wins the AI coding market but whether "neutral ground" for source code — the role GitHub played for a decade — survives as a category at all. For now the deals are closing faster than the frameworks are forming, which is itself part of the story.

What Teams Should Do Now

None of this is an argument against adopting agent-native tooling. The productivity gains are real, and the teams that refuse to use agents because of custody concerns will simply lose to the teams that use them carefully. The argument is for adopting with custody in mind — for keeping the escape hatches open even while you enjoy the integration. A few principles hold up regardless of which estate you lean toward.

The throughline is simple: enjoy the integration, but never let it become irreversible by default. The vendors are assembling these estates precisely because the lock-in forms quietly, without a decision. The countermeasure is to make the decision explicit — to treat custody of your own code as a property you deliberately retain rather than one you absentmindedly hand over in exchange for a better autocomplete.

The deeper structural question — whether agent-native source control becomes the default for serious engineering organizations, and how quickly — is the one I have staked out a falsifiable position on in my prediction on agent-native git going mainstream. The short version is that I expect the integrated estates to win the default, and I expect the cost of that default to be paid in custody. For the human side of what that transition feels like inside a team, I wrote a short piece of fiction about the last pull request a certain engineer ever reviewed, in The Last Pull Request. And for the deal mechanics and the wider consolidation, my news analysis of the SpaceX–Cursor acquisition and Origin lays out the specifics.

Conclusion: The Contested Layer Moved

For three years the industry told itself a story in which the contested layer of AI was the model. Whoever had the best model would win; everything else was commodity plumbing. That story was always incomplete, and in software development it has now been overtaken by events. The model matters, but the model is becoming something every serious player can build — Cursor is training its own, OpenAI has several, Microsoft has its own line. When everyone has a frontier model, the model stops being the moat.

What does not commoditize is custody. The place your code lives, the layer where changes are judged, the host that serves as your agents' memory — these are the positions that create durable power, because they are the positions that are expensive to leave and that get more expensive every day you stay. SpaceX did not spend $60 billion on an autocomplete. It spent $60 billion on a path to controlling the full lifecycle of how software gets made, starting at the cursor and ending at the commit.

The editor wars are over, and they turned out to be a qualifying round for a much larger contest. The real game is custody of code, and it will be won in the layer that almost no one was watching while everyone argued about the model: source control. The teams that understand this will hold onto their escape hatches and adopt with their eyes open. The teams that do not will wake up one fall morning to find that their most important asset lives, end to end, inside someone else's estate — and that the cost of leaving has quietly grown larger than the cost of staying.