Origin: When the Forge Goes Agentic, Self-Hosting Stops Being a Hobby
On June 16, at Fort Mason, Cursor held its first Compile conference. Three announcements, and the press settled on a convenient reading: a GitHub competitor, an iOS app, a new model. All true, and all beside the point. The political dimension of this moment I have already covered in an earlier article. Here I am going one layer down, into the plumbing, into the place where code actually lives. Because the most consequential announcement at Compile was not a product; it was a reversal of assumptions: the forge, the place where your code is stored, reviewed, and merged, has just stopped being designed for you.
And once the most intimate object of the craft, the repository, is rebuilt for the agent and then absorbed by the player that already owns the compute, the model, and the IDE, self-hosting stops being a nostalgic craftsman’s reflex. It becomes a strategic position. That is the thesis. Let me say it plainly up front, because the framing slips easily into caricature: the problem is not one man, it is a single point of control over the entire chain. It would be exactly the same if Microsoft, Google, or any other player ended up owning everything. What is at stake is structural, not personal.
What a Forge Built for Agents Really Changes
Git, and GitHub on top of it, were designed for a human pace. You open a branch, you code for a few hours, you open a pull request, you wait for a colleague to review it, you merge. The whole rhythm is measured in hours and days, and that is fine, because a human types only so fast. The permission model, the CI integration, the review process: all of it assumes a developer of flesh and blood, slow, attentive, and only occasional in their dealings with the repository.
Origin starts from the opposite assumption. The primary user is no longer the human, it is the agent. The figures shown on stage are not there to impress; they describe a design constraint: according to the metrics Cursor claims, on the order of 296,000 clones per hour, roughly 22.6 commits per second on a single repository, global synchronization reportedly under 400 milliseconds, and automatic failover within a few milliseconds. Keynote numbers, so take them for what they are, orders of magnitude that signal intent more than an independent benchmark. Storage runs on S3, with replicas that scale without limit. More tellingly, the forge ships an agent-driven merge-conflict resolution engine and agentic resolution of CI failures. In other words, the repository no longer assumes a human who drops by now and then; it assumes swarms of agents pushing code in parallel, continuously, at a frequency no forge of the human era ever had to absorb.
The technical foundation comes from Graphite, acquired in December 2025, whose expertise lay precisely in high-frequency review and stacked PRs. The lineage is coherent. What changes is not raw performance, it is citizenship: in Origin, the agent is a first-class citizen, and the human becomes a supervisor. You no longer commit, you arbitrate. This is a shift in role, not a feature update, and it has to be named as such before we can weigh its consequences.
The Trap Is Not the Forge, It Is the Concentration
An agentic forge, in itself, is neither good nor bad. The question that decides everything is this: who owns it, and what else do they own? And here, Compile delivered the real news, the part that was not a product. On the same day, SpaceX exercised its option to acquire Anysphere, Cursor’s parent company, for 60 billion dollars in stock, the largest acquisition of a venture-backed startup ever recorded, with closing expected in the third quarter of 2026. The option signed in April offered two doors: buy at 60 billion, or pay 10 billion to extend a mere collaborative training arrangement. The acquirer chose ownership.
Take an inventory of what a single player now brings together. The compute: Colossus, xAI’s supercomputer in Memphis, on the order of a million H100-equivalents, with an announced ceiling higher still. The model: a new frontier-class model of roughly 1.5 trillion parameters, trained from scratch on that Colossus and fed by the working sessions of Cursor’s own developers. The IDE: Cursor itself, more than a million developers, a presence across two-thirds of the Fortune 500. The forge: Origin, where code will now live. And the downstream data: your workflows, your prompts, your way of solving problems, all of it cycled back as training fuel. Compute, model, tool, forge, data. The vertical integration is complete, from the silicon all the way to your intent.
Let me repeat it, because it is the heart of the matter and the personal framing is misleading: the problem is not Musk. It would be the same if this point of control were called Microsoft, Google, or OpenAI. What is at issue comes down to two mechanisms: vertical integration from one end of the chain to the other, and the capture of training data downstream, meaning your own work recycled into an advantage for the owner. Neither one depends on the personality of whoever holds the wheel.
This is where the moat shifts. As long as model quality made the difference, anyone could hope to close the gap. Once the marginal cost of inference trends toward zero because you own the silicon, the center of gravity is no longer model quality but access to compute. Until now, Cursor was model-agnostic: it routed to Claude, to GPT, to its own Composer models, and it was precisely for that freedom that a million developers had chosen it. How long does that neutrality survive once the owner has every incentive to push its in-house model and, incidentally, to let the experience of rival models quietly degrade? The question is not malicious, it is mechanical: an acquirer’s incentives change the day the deal is signed. We then tip into a dynamic that is simple to state: when the marginal cost of code trends toward zero, value no longer lies in writing it, but in owning the infrastructure that runs it. The developer loses what made them scarce. This is the great dispossession I described elsewhere, here transposed onto the forge.
I hold myself to naming the limits, because clarity is not catastrophism. The acquisition is not closed: it still hinges on regulators and on a timeline, the third quarter of 2026, that could easily slip. And it has to be said bluntly, folding Cursor into an organization that just lost its eleven co-founders in the first quarter, and that is rebuilding itself the hard way, is no small thing: the execution risk is real and it weighs on the entire scenario. So, caution on the timing. But on the trajectory, there is no ambiguity: the direction of the current is clear, and it runs toward concentration. It is that concentration, more than any particular product, that should occupy us, much like the dependency sold to us along with AI loops.
The Sovereign Version: What I Actually Do About It
The lazy reflex would be to boycott Cursor. Wrong answer: the tool is excellent, and refusing the velocity of agents on principle is to doom yourself. The right answer is not to flee the tool, it is to never let it become the custodian of your intent. The sovereign boundary, in 2026, does not run through “don’t use agents.” It runs through “own the repository, own the port, own the intent.”
In practice, this comes down to three rules. First: workflows live in scripts and versioned files, never in a proprietary IDE feature. Anything that is merely a setting in the interface of an editor that has been bought out is a dependency in disguise. Second: the repository stays with me. A self-hosted forge, Forgejo or Gitea on my own infrastructure, or even bare git behind nginx, is enough to keep ownership of the code. As long as the forge speaks standard Git, the exit always remains possible, at least for the source code. But let me be precise, because the nuance matters a great deal: storing code and absorbing an agentic cadence are two distinct problems. Bare git, or a basic Gitea, will buckle under a cadence of that order, with its agent-driven conflict resolution and CI loops, where Origin absorbs it thanks to the infrastructure inherited from Graphite. Sovereign self-hosting will therefore have to evolve as well: it will no longer be about merely keeping your repositories, but about running your own agent orchestrators, via MCP, on your own servers. Otherwise you will be sovereign, yes, but cripplingly slow next to the teams on Origin. Sovereignty without orchestration is sovereignty in a museum. Third: the model stays interchangeable, and the downstream data, my sessions and my code, does not go off to bolster a third party’s moat for free.
This is exactly the logic of the e-commerce engine I am building right now in Symfony, in a hexagonal architecture. If I imposed a clean boundary between the domain and the infrastructure, it was not out of academic affectation: it was so that the AI provider, the forge, the external service would remain replaceable adapters, never the core. The inbound MCP adapter I am developing to pilot administrative tasks through AI is the illustration: the AI acts through a port that I own. If the provider changes hands, pricing, or policy, I swap the adapter, not the domain. The port is mine, the intent stays mine. It is the same conviction that led me to argue that websites should learn to speak to agents through an open standard rather than by the grace of a single player.
And this is where MCP stops being an architectural detail and becomes the decisive weapon against lock-in. An IDE’s lock-in holds only as long as the agentic power stays welded to the editor. MCP pries the two apart: the day Cursor turned too prescriptive or too closed, an open-source editor, VSCodium or Zed, wired to local and sovereign MCP servers, restores exactly the same agent capability. The real exit brick, then, is not just Git for the repository, it is MCP for the agent. One protects your code, the other protects the way you work with it; you need both, and that pairing is precisely what the integrated stack would like you to forget.
Let me be honest about the price of this discipline, because sovereignty carries a cost it would be dishonest to hide. For many teams, self-hosting is a genuine operational burden, and it means accepting a lag behind the agentic features of proprietary forges, which move fast and with resources no in-house team can match. That drag is serious, and it is often the deciding factor, not ideology. The good news, and this is the whole point, is that you are no longer forced to choose between agentic velocity and independence. The standards, Git on one side, MCP on the other, let you capture the former without handing the latter to a single owner: the forge stays yours, the agent keeps its power.
It is in this light that self-hosting stops being a holdout’s hobby. Proxmox, FreeBSD, nginx, PostgreSQL: this is not folkloric resistance, it is the assurance that agentic cadence is not paid for in dependency. And the good technical news is that a sovereign agentic forge is within reach. Agents drive a forge through an API and through MCP; nothing in that machinery requires the forge to be the dominant owner’s. What Origin does on behalf of a single player, open building blocks can do on your behalf. Velocity belongs to no one; only ownership is up for negotiation.
A Three-Year Scenario: Polarization, Not a Tipping Point
I do not believe in the total victory of one camp. I believe in polarization, and that is a more useful forecast than a prophecy of apocalypse.
On one side, the mass market. Integrated forge, agents by default, the owner’s compute, spectacular productivity, and lock-in accepted as the price of convenience. The majority of companies will go there, because it is convenient, and convenience almost always wins. No point lamenting it, just note it: for anyone who wants to ship fast without asking architectural questions, the closed stack is unbeatable in the short term, and the operational cost of a sovereign alternative will weigh heavily in the balance.
On the other side, a minority that will choose sovereignty not out of ideology but out of necessity. Regulated sectors first, healthcare, defense, law, finance, where entrusting your code and your data to the infrastructure of a third party subject to the Cloud Act is simply not an option, as I laid out when I argued for local open source as the only path to independence. And then the craftsmen, the independents, the agencies like mine, for whom owning your means of production has always been a discipline. Self-hosted forge, interchangeable models, often open-weight and local, agents driven through ports you own. The reasoning is not sentimental, it is architectural: the more the dominant stack closes in, the more the open building blocks gain defensive value.
This is where the realistic hope lies. Consolidation will paradoxically strengthen the sovereign ecosystem. Every turn of the screw by the dominant point of control makes standard Git, MCP, open-weight models, and free forges a little more valuable, because they are the guarantee of an exit. As long as the forge speaks Git and the agent speaks MCP, the door stays open. Standardization is our best insurance, and it cannot be decreed, it is chosen, one repository at a time.
The real risk, in the end, is not technical, it is cultural. An entire generation of developers may never have known anything but the owner’s forge, and for them the very idea of owning your repository will seem exotic, almost eccentric. The battle is fought less over the tool than over the reflex. You can lose sovereignty without a single line of code forbidding it, simply because no one is left who thinks to claim it.
My Take
Compile is not the purchase of a code editor. It is the moment when the most intimate layer of the craft, the one where code is stored and merged, tipped over to the side of the agent, and in the same motion to the side of a single point of control that already holds the rest of the chain. That this point of control goes by the name SpaceX today changes nothing about the matter: the danger is in the structure, not in the face. Origin is an excellent product and an alarm bell, both at once, and you have to be able to hold both ideas together without sacrificing either.
My rule fits on one line: adopt the velocity of agents, refuse the dispossession of the repository. Keep the port, keep the intent, keep the repository; the rest is just an adapter you swap out. Self-hosting, long seen as a power user’s affectation, is becoming in 2026 the most concrete form of freedom a developer has. It is not a retreat. It is a position, and it can be defended.