The number Michael Truell put on the screen early in the keynote was the one that mattered. Over 95% of people who use Cursor now use it primarily as an agent. On a per-request basis, agents are used roughly five times more than assistive features like Tab, and when you control for lines of code written, the gap is orders of magnitude wider (keynote, 5:10). A company that started in 2023 as an autocomplete-flavored fork of an open-source editor now runs almost entirely on agents doing whole units of work. Compile 2026, Cursor’s first conference, was the event where the company stopped describing itself as an editor and started describing itself as something much larger.
The framing is impossible to separate from the financial backdrop. On June 16, days after SpaceX’s record Nasdaq debut, the rocket company signed a definitive agreement to acquire Anysphere, Cursor’s parent, in an all-stock deal valuing it at $60 billion. SpaceX paid almost nothing in cash; it paid in newly liquid stock. So when Truell announced a new model and noted it was “backed by our partnership with SpaceX, which, as you all know, is a little bit more than a partnership,” then added “it’s been a slow news day” (keynote, 25:12), the room understood. The conference was a coming-out party for a company that just became part of the most aggressively vertically integrated firm in technology.
Why the deal structure is the strategy
It is worth slowing down on the “didn’t spend a dollar in cash” detail, because it is not trivia. It is the engine. An all-stock acquisition done days after a record IPO is a specific maneuver: SpaceX converted freshly minted, freshly liquid equity into a frontier coding company without touching its operating cash. The newly public stock is the currency, and the IPO is what made that currency spendable. Read in that order, the timeline is not a coincidence; it is a sequence. Go public, then immediately use the public stock to buy the thing you could not have afforded in cash the week before.
What SpaceX bought is not really an editor. It bought a demand sink for compute it already controls. xAI’s Colossus cluster is a fixed asset that costs money whether it is busy or idle. A coding product with millions of daily agent runs is one of the few workloads that can absorb that capacity at high utilization and convert it into revenue per token. The cleanest way to understand the acquisition is as vertical integration in the literal industrial sense: the company that owns the power plant just bought the factory that consumes the most electricity.
That framing changes how to read every product announcement that followed. Cursor is no longer optimizing for gross margin on someone else’s API. Inside the combined entity, the compute is a transfer cost, not a vendor invoice. That is the structural advantage no competitor wrapping Claude or GPT can match, and it is the reason the from-scratch model went from implausible to inevitable the moment the deal closed.
The three announcements
Strip the staging away and Compile shipped three concrete things, each at a different stage of readiness.
| Announcement | What it is | Status as of Compile |
|---|---|---|
| Cursor Mobile | iOS app to monitor, unblock, and steer cloud agents from a phone, plus remote control of local agents | TestFlight beta, opening “in the coming days” |
| Origin | An agent-native Git platform: code hosting, review, and merge built for fleets of agents instead of a handful of humans | Live for internal use and select design partners; general rollout “this fall” |
| From-scratch model | A frontier coding model “as big as Opus and GPT,” trained from scratch on 10 to 20 times more compute, via SpaceX | ”Late in the stages of training,” release “in the next couple of weeks” |
None of these is an editor feature. A mobile control plane, a code-hosting platform, and a foundation model are the components of an operating company for software production. Read in sequence, they describe a single strategy: own every layer the agent touches.
The vertical-integration bet
Truell’s clearest articulation of the product thesis was about colleagues, not tools. Most developers today, he argued, are still handing agents bites of work, 30 minutes here, an hour there, and running three to five locally on their own machines where they bottleneck each other on the same codebase. “That’s obviously not the future,” he said. “You’re not going to have coding ASI and just be running all these agents locally on your computer” (keynote, 6:59). The intended future is one where you hand an agent a whole project, it works for days on its own computer, and it returns the thing “done, completed and tested.”
That vision forces the vertical stack. An agent that works for days needs its own dev environment, which is why cloud agents got a heavy upgrade: their own cloned repos, installed dependencies, and credentials, plus the ability to run tests and produce reviewable screenshots. Kevin Niparko, who leads a product team, said cloud agents are now three times faster and have hit three nines of reliability, with over six million automation runs since the feature launched (keynote, 16:00). One customer, Amplitude, is running a background migration that swaps twenty thousand React components for their Tailwind equivalents using a custom agent deployed on Cursor.
The reframing here is from product to platform. Truell announced an SDK and leaned on the word “hackable,” arguing that a tool this central to a team’s work has to be programmable, not just clickable, and accessible to other agents and not only to humans (keynote, 8:05). The CLI got more than 50 quality-of-life improvements. The message to enterprises is that Cursor wants to be infrastructure, the layer you build on rather than the app you open.
The model that needed a rocket company
The boldest announcement was the one with the least to show. Cursor is training a model unlike anything it has built before, and Truell named three differences. It is big, “as big as Opus and GPT.” It is trained from scratch rather than starting from an open-source base, which lets the company control every behavior. And it runs on 10 to 20 times more compute than Cursor has ever had (keynote, 23:06).
That third point is where the SpaceX deal stops being a financial footnote and becomes a product input. Cursor’s own blog post on the partnership traces the Composer lineage and the compute wall it kept hitting. The models were good; the constraint was GPUs and hours, not ideas. The acquisition resolves that by routing Cursor onto Colossus, the xAI training cluster, where reporting on the deal describes access to well over 200,000 GPUs. The verified chatter framed the new model as a 1.5-trillion-parameter system trained from scratch on 100,000-plus GPUs. Cursor has not confirmed those exact figures, and the prudent reading is to treat them as community estimates until the model ships.
| Model | Released | What changed |
|---|---|---|
| Tab models | 2023–2024 | Cursor’s first models; powered autocomplete, “wrote a lot of the world’s code” |
| Composer 1 | Nov 2025 | First agentic coding model; got RL working at scale on real workloads, from an open-source base |
| Composer 1.5 | Late 2025 | Scaled the same RL process up |
| Composer 2 / 2.5 | Early 2026 | Added continued pretraining (tens of trillions of tokens) and real-time RL updating every few hours |
| From-scratch model | ”Next couple of weeks” | First fully in-house frontier model; 10–20x compute via SpaceX; “intelligent beyond just coding” |
Truell was candid about the stakes of staying cost-competitive. “It would be very sad,” he said, “if the models got very capable” but the ability to use them was “gatekept to the largest companies that had lots of capital” (keynote, 12:17). The framing is populist, the structure is not. A from-scratch frontier model on a private 200,000-GPU cluster is the most capital-intensive bet in the building.
Origin: storing the flood
The Origin announcement came from Tomas Reimers, a Graphite co-founder who joined Cursor when it acquired his company in January. His pitch started from a measured observation: building software is about far more than writing code. It is testing, reviewing, merging, and deploying. Graphite built tooling for those steps and served demanding teams including Shopify, Snowflake, Notion, and Figma. Then, he said, AI tooling made those same workflows unreliable, because the tools assumed humans, not fleets of agents, were generating the changes (keynote, 19:35).
Origin is the response: a Git-compatible platform architected for agent scale. Reimers described a novel Git architecture built on cloud primitives, load-tested by simulating thousands of agents pushing and pulling against a single repository at once. Powered by the same intelligence that runs Cursor, Origin resolves merge conflicts, fixes CI failures, addresses review comments, and only tags a human when it needs one, which he claimed cuts time-to-review by more than half. It is live for internal use and design partners now, with general availability slated for the fall.
The honest reading, echoed by outside analysis, is that Origin is a thin launch with a real trust problem. Asking teams to move their source of truth off GitHub is the single highest-friction switch in a developer’s life, and a fall-dated waitlist is a long way from a migration. But the ambition is unambiguous. Cursor is not building a GitHub integration. It is building a GitHub replacement, on the premise that the primary author of code is no longer a person.
The lock-in math nobody said out loud
Stack the four announcements and a quieter mechanism appears, one no speaker named because naming it would be impolitic. Each layer Cursor owns raises the cost of leaving by a different kind of friction, and the frictions multiply rather than add.
| Layer | What leaving costs you | Type of lock-in |
|---|---|---|
| Model | Re-tuning prompts and agents to a different model’s quirks; losing model-specific RL behavior | Behavioral |
| Harness (editor, CLI, SDK) | Rewriting automations and custom agents built against the SDK | Technical |
| Origin (code host) | Migrating your source of truth, history, CI, and review workflow | Data-gravity |
| Mobile / control plane | Rebuilding the way your team supervises long-running agents | Operational |
Any one of these is survivable. A team can swap a model. It can rewrite a few scripts. But a shop that runs its agents on Cursor’s model, hosts its code on Origin, scripts its pipeline against the SDK, and supervises the fleet from Cursor Mobile is not using a tool anymore. It is living in an operating system. Leaving means changing four things at once, and the data-gravity layer, where your entire history lives, is the heaviest of them. That is the real reason Origin matters more than its thin launch suggests. The model and the editor are sticky; the place your code physically lives is the anchor.
This is also why the “still supports third-party models” reassurance deserves an asterisk. Open support and aligned incentives are different things. As long as the cheapest, fastest, most deeply integrated path runs through Cursor’s own model on Cursor’s own compute, third-party support is a courtesy that erodes by default, not by decree. Nobody has to remove the exit. They only have to stop maintaining the road to it.
The warning delivered beside the roadmap
The most interesting thing about Compile is that Cursor put the counter-argument on its own stage. Ryo Lu, who leads design, gave a talk called “Closer to the Material” that functions as the keynote’s conscience. His premise: when agents can build almost anything almost instantly, “the question is no longer just, can we build it? The question becomes, what should exist?” (Ryo Lu, 1:33).
His warning is precise and uncomfortable for a company selling acceleration. A faster loop is good only if you stay inside it. When the loop gets hidden, he argued, the tool becomes a black box, and building turns into something closer to gambling:
You make a wish. You wait. You get an output. Accept or reject. If it works, you don’t really know why. If it fails, you don’t really know where. This is not building. This is pulling a slot machine.
The consequence is not catastrophic failure but quiet mediocrity (Ryo Lu, 4:44):
If AI makes execution cheaper but judgment weaker, we do not get a renaissance. We get slop with working buttons.
The danger, he said, is “that the interface turns people into approvers.”
His answer is a design principle he calls Glass, an interface that lets you see through the agent’s work: see the plan, watch the tools stream in, stop it, take over, inspect as deeply as you want. “Black boxes optimize for clean output,” he said. “Glass optimizes for human agency” (Ryo Lu, 10:36).
The deeper move in the talk is the relocation of craft, and it is worth taking seriously because it reframes the whole anxiety about automation. “Craft does not disappear,” he said. “It moves” (Ryo Lu, 17:34). When generation was the expensive step, craft lived in execution: the skill was in writing the code well. When generation costs nothing, that skill commoditizes, and craft migrates to the two ends of the loop that did not get cheaper. Upstream, it becomes judgment about what to build and, harder, what to refuse to build. Downstream, it becomes responsibility for what you actually ship under your name. “Taste is not a prompt. Caring is not a parameter.” The middle hollows out; the edges get more valuable, not less.
That is a more useful map than the usual “will AI replace developers” framing, because it says precisely which part of the job evaporates and which part intensifies. The part that evaporates is the typing. The part that intensifies is the deciding. A developer who only ever learned the typing is exposed. A developer whose value was always in judgment and ownership gains ground. The slot-machine failure mode is what happens when a person trained for the middle of the loop is handed a tool that automated exactly that, and responds by becoming an approver of outputs they no longer understand.
It is tempting to read the two talks as contradiction. They are closer to a division of labor. Truell sells the loop getting faster and more autonomous. Ryo Lu insists the faster loop is worth nothing if the human steps out of it entirely. Both can be company strategy at once, and Cursor is betting that legibility is a feature it can sell rather than a brake on the automation it is racing to build. There is a real tension here the company has not resolved, only named: every dollar of the SpaceX bet is spent making the loop more autonomous, and autonomy is precisely the pressure that pushes humans toward the approver seat Ryo Lu warned about. The Glass principle is the promised countervailing force. Whether it gets the same engineering budget as the autonomy it is supposed to balance is the thing to watch, not the thing to take on faith.
Where this diverges from the field
| Topic | Prevailing position in 2026 | Cursor’s bet at Compile |
|---|---|---|
| The model layer | Coding tools wrap third-party frontier models (Claude, GPT, Gemini) | Train a frontier model from scratch, in-house, on a private supercluster |
| Where code lives | GitHub is the immovable default | Replace it with Origin, a forge designed for agents first |
| Agent location | Run agents locally, a few at a time | Move agents to the cloud with their own dev environments, running for days |
| The interface | Chat panel bolted onto an IDE | Glass: a see-through environment where humans and agents share the same material |
| The human’s job | Prompt, then accept or reject | Stay an author; craft moves to judgment and responsibility |
The throughline is ownership. Most of the field rents its critical inputs: someone else’s model, someone else’s code host, someone else’s compute. Cursor’s deal with SpaceX lets it stop renting. That is the divergence that matters, and it is only available to a company with access to a 200,000-GPU cluster it does not have to pay cash for.
What builders should take from it
| If you are… | What Compile suggests you do |
|---|---|
| A solo developer or small team | Lean into cloud agents and automations now; the local-only workflow is the one Cursor is explicitly building away from |
| Evaluating a coding-model switch | Wait for the from-scratch model’s benchmarks and price before committing; “as big as Opus” is a claim, not a result |
| Considering Origin | Treat the fall rollout as a pilot, not a migration; do not move your source of truth off GitHub on a waitlist promise |
| Worried about model lock-in | Note that Cursor still supports third-party models, but the incentives now point toward its own; keep an exit path |
| Designing your own agent UX | Steal the Glass principle directly: stream the plan, the tools, and the diffs; make stopping and taking over a first-class action |
The high-impact takeaway is not a product to adopt today. It is the shape of the bet. A coding company now believes the winning move is to own the model, the harness, the code host, and the compute, and to do it inside a rocket company’s balance sheet. Whether that produces better software or just more of it is the open question Ryo Lu was hired, apparently, to keep asking.
The bull and bear case
The vertical bet is genuinely double-edged, and the honest way to hold it is to state both sides at full strength.
The bull case is that integration wins when the layers are tightly coupled, and a coding loop is the most tightly coupled product in software. A model that was trained knowing it would run inside this harness, against code stored on this forge, supervised through this control plane, can be co-designed end to end in a way no assembly of third-party parts can match. Apple made this argument about silicon and won. SpaceX makes it about rockets and engines and won. If software production is a single physical loop, the company that owns the whole loop can tune it past anything its renting competitors can reach, and the compute-as-transfer-cost advantage means it can do so while undercutting them on price.
The bear case is that integration is also fragility, and that Cursor just multiplied its surface area for failure. It now has to win four hard races at once: build a frontier model that beats Anthropic and OpenAI on their own turf, replace the most entrenched developer habit on earth in GitHub, ship a reliable mobile control plane, and keep the editor ahead of a swarm of fast-following forks. A company spread across four fronts can lose on any one of them, and the most likely loss is the model: “as big as Opus” is an aspiration, and frontier training has humbled better-funded teams. If the from-scratch model lands merely competitive rather than ahead, the entire ownership thesis loses its keystone, because the one input that justified the supercluster turns out to be available, cheaper, from someone else.
The synthesis is that the SpaceX balance sheet changes the odds on the bear case more than anything Cursor could have done alone. The usual failure mode for the vertical bet is running out of money before the most capital-intensive layer pays off. That is exactly the layer the acquisition de-risks. Cursor can now afford to lose the model race for longer than any independent competitor can afford to run it.
How the room read it
The bull and bear cases are not abstractions; they are the two halves of the actual argument that played out on X in the days around the deal and the conference. Worth reading both, because the skeptics raised a number the keynote did not.
The bull reading treats the acquisition as the moment a struggling AI division got a product and a struggling product got compute. The analyst account @LLMJunky put it bluntly: “60% of @xai Q1 capex went to building out AI infrastructure. But they really didn’t have a great product to bolt onto it. In fact, they were the butt of many jokes. Not anymore.” His tally of what the combined entity now holds reads like the vertical stack restated by an outsider: “Colossus compute, new 1.5T param model trained from scratch, Composer 2.5, Cursor for distribution, Origin as the code host,” and, above all, “an incredible wealth of data to train future models. That is the entire stack, end-to-end.” The @MilkRoadAI thread made the same point from Cursor’s side: a team “with the genuine potential to compete at the frontier, the one thing holding them back was compute,” had just been handed “the largest GPU cluster in the world.”
The bear reading is sharper, and it supplies the fact the keynote conspicuously omitted: Cursor’s enterprise momentum was already sliding. Citing Ramp card-spending data, @Ric_RTP argued that Cursor’s enterprise market share “fell from 41% in June 2025 to 26% in May 2026, bleeding ground every month to GitHub Copilot and Amazon Q,” and framed the price as paying “a premium for declining momentum.” That account read the timing as deliberate, landing “in the exact window between Anthropic filing its prospectus and pricing its IPO,” and called the deal “a hit job on Anthropic’s IPO,” since Cursor was Anthropic’s single largest enterprise pipeline. A shorter post from @franklyankish compressed the cynical version to one line: “The price isn’t for the editor, VS Code is free. It’s for the developer base, $2.6B revenue, and feeding xAI/Grok’s weak coding capabilities via Colossus compute.”
Both readings can be true at once, and the synthesis maps cleanly onto the from-scratch model. If the model lands ahead, @LLMJunky’s “Grokomposer in the conversation for best SOTA” is the outcome and the share decline reverses. If it lands merely competitive, @Ric_RTP’s “premium for declining momentum” is what SpaceX actually bought. The discourse, in other words, was arguing about the same keystone this piece identified, and the number the skeptics dragged in, the share slide from 41% to 26%, is the one most worth holding onto. (The 1.5-trillion-parameter, 100,000-GPU figure circulated by accounts like @tokens remains a community estimate, not a Cursor-confirmed spec.)
What to watch
The thesis in this piece is falsifiable, which is the only kind worth writing. Here is what would confirm or break it over the next few quarters.
| Signal | If it happens | What it would mean |
|---|---|---|
| The from-scratch model ships and benchmarks at or above Opus/GPT on real coding tasks | Confirms the bull case | The keystone holds; ownership thesis intact |
| The model ships merely competitive, or slips past “a couple of weeks” into quarters | Confirms the bear case | The supercluster bought parity, not advantage |
| Origin reaches general availability on schedule with real migrations, not just design partners | Confirms data-gravity lock-in is real | The anchor layer is working |
| Origin stays in perpetual “fall rollout” | Weakens the lock-in math | The stickiest layer never sets |
| Third-party model support quietly degrades (slower updates, worse defaults) | Confirms the incentive-erosion read | The exit road stops being maintained |
| A visible “Glass” surface ships in the product, not just the talk | Confirms legibility is strategy, not theater | Ryo Lu’s warning has teeth |
The single most important of these is the first. Everything else in the vertical stack is execution risk on known problems. The from-scratch model is the one bet where Cursor is wagering that more compute, applied from scratch, beats the accumulated head start of the two labs that have been doing nothing else for years. That is the wager the rocket company’s stock was spent to place.
The bet, stated plainly
Compile 2026 is the clearest statement yet that the AI coding race has stopped being about features and become about integration. The editor wars are over; Cursor won enough of them to stop fighting and start absorbing the layers beneath and around the editor. The from-scratch model is the tell. You do not spend a private supercluster’s worth of compute to make a better autocomplete. You spend it to stop depending on the labs you used to wrap.
The risk is the one stated from Cursor’s own stage. A fully owned, fully automated loop is also a fully sealed one, and a sealed loop is exactly the black box Ryo Lu warned against. The company is betting it can have both: the vertical stack that makes agents autonomous, and the Glass principle that keeps humans inside the decisions. That is a genuinely hard thing to hold together, because every incentive in an automation business pushes toward hiding the loop, not exposing it. The honest verdict is that Cursor has announced the most ambitious vertical integration in developer tools and, in the same afternoon, articulated the precise way it could go wrong. The interesting companies are the ones that say both out loud. The test is whether the warning survives contact with the roadmap.