Executive Summary

Key Numbers

The first two numbers give the size of the deal and the pace at which Cursor revises its model. The last two point at where the material for that pace comes from.

Sources: TechCrunch (Aug. 15, 2026), Cursor research blog (Mar. 26, 2026), Cursor Enterprise

The company behind Cursor is Anysphere. When SpaceX entered a model-training partnership with Cursor in April, it also took the right to buy the company for $60 billion. The terms of that arrangement were either to acquire or, failing that, to hand over about $10 billion. On June 16, days after its Nasdaq listing, SpaceX announced the definitive agreement, and the regulatory record shows the deal taking effect on August 14.

What that $10 billion consisted of says something about the deal before anything else does. The terms SpaceX set out in its IPO filings were a termination fee of $1.5 billion plus $8.5 billion in computing resources. Most of what SpaceX would have owed Cursor if it walked away was not cash but calculation. Between these two companies, compute was already working as a means of payment.

The consideration is entirely SpaceX Class A common stock. Against the valuation at listing, it works out to roughly 3.4% dilution. The listing itself raised more than $80 billion and lifted the company above a $2 trillion valuation, and the deal that followed it is the largest acquisition of a venture-backed startup on record.

Before the SpaceX offer arrived, Cursor was in the middle of raising $2 billion at a $50 billion valuation. The $60 billion price is roughly 15 times revenue, and over the same stretch Cursor's market share had slid from about 41% in June 2025 to about 26% in May 2026 by Ramp's spending data. Whatever held the price up, it was not share of the current market alone.

The post-close structure is worth a look too. Cursor does not run as a separate company. Its people and operations move inside SpaceXAI, the organization built on the xAI business SpaceX merged in earlier this year, and the model Cursor shipped the same week as the announcement already carries the name Grok 4.6. The company that receives requests from developers using Cursor and the company that trains models on those requests are now under one roof.

In April's partnership post, Cursor named its own bottleneck plainly. Composer 1.5 had scaled reinforcement learning by over 20 times and Composer 2 had added continued pretraining, and each step up in compute had translated to meaningfully more capable models. The company wanted to push training much further, it wrote, but "we've been bottlenecked by compute." August's acquisition post leads with the same theme, putting the world's largest GPU fleet first.

One thing does not fit. SpaceX also rents data center capacity to Anthropic and Google. Compute is a thing you can hand over by contract, and Cursor had in fact been running on Colossus infrastructure under exactly that kind of contract since April. What the extra $60 billion bought is not access to compute. It is whatever a compute contract does not transfer.

Cursor's Composer 2.5 post from May names it. Together with SpaceXAI the team is training a significantly larger model from scratch using 10 times more total compute, and it expects a major leap from Colossus 2's million H100-equivalents and "our combined data and training techniques." Data sits right beside compute in the list of what is being combined.

Why that seat is worth paying for is spelled out in a post Cursor's research team published in March. Facing 10 to 100 times increases in inference volume, the team asked how it could take those trillions of tokens and extract a training signal from them, and it calls this approach of using real inference tokens for training "real-time RL." The technique was first used to train the autocomplete model Tab, where it proved highly effective, and it is now being applied to the agent model Composer.

The same post explains the limits of a simulated environment. Coding is easier to simulate than a domain like robotics, but the greatest difficulty lies in modeling the user. The production environment for Composer consists of not just the computer that executes its commands but the person who oversees and directs its actions, and simulating the computer is far easier than simulating the person using it. Training on real inference tokens, Cursor writes, lets it use real environments and real users, which removes that source of modeling error.

The loop runs like this. Client-side instrumentation translates user interactions into signal, backend data pipelines feed that signal into the training loop, and each cycle starts by collecting billions of tokens from user interactions with the current checkpoint and distilling them into reward signals. The updated weights have to clear the eval suites, CursorBench among them, before deployment. The whole pass takes about five hours.

What the reward actually is comes from the A/B results Cursor published. Three metrics, measured on Composer 1.5.

Source: Cursor, Improving Composer through real-time RL

The first two metrics are a developer's judgment written down as a number. Did the developer leave the code the agent changed in place, or did they come back unhappy with the result and say so. No benchmark sells that signal and no simulation produces it. It appears only while a developer is actually reworking the code. Cursor names the weakness of the method in the same post. Models are adept at reward hacking, and one example it gives is learning to split code into artificially small functions to game a complexity metric.

Researchers outside Cursor have looked at the same signal. A paper released in May by teams from Notre Dame, Vanderbilt, and Google gathered 20,574 real coding-agent sessions from 1,639 repositories to study what breaks down between developers and agents. Its test for a breakdown is effectively Cursor's reward signal: the paper operationalizes misalignment as a breakdown made visible through developer pushback. The findings show 90.50% of episodes imposing effort and trust costs rather than irreversible system damage. Visible resolution appears in only 9.33% of episodes, and 91.49% of those resolutions still require explicit user correction.

The asymmetry is in the source material. What the researchers could work from were conversation records developers had chosen to publish to open repositories, and only 3,234 of them were confirmed Cursor IDE sessions. Cursor receives records of the same kind directly from live use at more than 50,000 customer organizations. The paper's own discussion notes that treating logs as a primary behavioral signal would let the same pipeline run continuously on live sessions. On the vendor's side of the line, it already does.

So whose sessions go into that loop? The answer sits in the data use overview Cursor updated on July 15, and the fork is a single setting called Privacy Mode.

With the mode enabled, customer data will not be used for training by Cursor, and Cursor states that it maintains zero data retention agreements with all providers. Turn it off and the sentence changes. Cursor may use and store codebase data, prompts, editor actions, code snippets, and other code data and actions to improve its AI features and train its models. The raw material for the reward signals in the previous section is sitting inside that list.

A few conditions survive turning the mode on. Model providers, Cursor included, may run risk classifiers to detect violations of terms and usage policies, and prompts or conversations that trigger abuse detectors may be stored for investigation. Models without zero data retention are designated as such or require an admin to opt in before a workspace can use them. The provider documentation the overview points to lists SpaceXAI alongside OpenAI and Anthropic.

The same document is explicit about the paths data travels. Even if you use your own API key, requests still go through Cursor's backend, because that is where the final prompt is assembled. Indexing a codebase uploads it in small chunks so embeddings can be computed on the server, and while the plaintext ceases to exist after the life of the request, the embeddings and metadata such as file names and hashes may be stored in Cursor's database.

At the organizational level there are controls. Privacy Mode can be enabled by a team or enterprise admin, and new team members inherit the team's settings. Cursor's enterprise page states that with Privacy Mode enabled org-wide, your code is never used for training. That sentence describes what happens once an admin has made that choice, and where each developer account across 50,000-plus customer organizations currently sits is something only the organization that deployed the tool can check.

The items that come up when a team evaluates a coding agent are usually language support, context length, and per-seat pricing. The asset this deal put a price on appears nowhere on that list. Translated into the language of data, the things to settle in the same meeting come to four lines.

• What is the default. Does training use start switched on or off, and does the answer differ between personal accounts and organizational ones
• Can the organization lock it. Can an admin enforce the setting, do new members inherit it, and can an individual reverse it
• Which companies does it pass through. The list of model providers and each one's retention terms, the procedure that opens an excepted model, and whether requests route through the vendor's backend even with your own key
• What is left behind. Beyond the code itself, where embeddings, file names, and hashes are kept and for how long, and what happens to them when the contract ends

All four ask where the logs go rather than what the tool can do. They are also the items whose answers change when a vendor is acquired or swaps model providers. This deal handed Cursor's customers a new company on the path their code travels, and SpaceXAI was not a line on the feature comparison they used when they chose the tool.

One more line belongs on the list, and it points at our own side. Does the record of where a developer accepted the agent's suggestion and where they rewrote it stay with us. If it does not, the same session becomes material for the vendor's next model and, for us, nothing more than work that already happened. On how data turns into a liability during acquisition diligence, see the hidden data debt surfacing in AI acquisition diligence, and on training environments for agents becoming a product of their own, see the fake company where AI agents can fail.

Choose to keep it and the uses are already documented. The paper cited above notes that running the same analysis continuously over in-house sessions gives developers feedback they can look back on and gives the people evaluating tools a basis grounded in actual use. If the record of where a developer reversed the agent lives in our repository too, it is something our own team can read before it is ever a signal handed to a vendor.

Cursor Official Documents

• 1.Cursor Team. (Aug. 14, 2026). "Cursor is now a part of SpaceX." Cursor Blog.
• 2.Cursor Team. (Apr. 21, 2026). "Cursor partners with SpaceX on model training." Cursor Blog.
• 3.Jackson, J., Trapani, B., Wang, N., & Zhu, W. (Mar. 26, 2026). "Improving Composer through real-time RL." Cursor Blog.
• 4.Cursor Team. (May 18, 2026). "Introducing Composer 2.5." Cursor Blog.
• 5.Anysphere. (Jul. 15, 2026). "Data Use & Privacy Overview." Cursor.
• 6.Anysphere. (Apr. 24, 2026). "Security." Cursor.

Coverage

• 7.Ha, A. (Aug. 15, 2026). "SpaceX officially closes its Cursor acquisition." TechCrunch.
• 8.TechCrunch. (Jun. 16, 2026). "SpaceX to acquire Cursor for $60B in stock, days after blockbuster IPO." TechCrunch.
• 9.Bloomberg. (Aug. 14, 2026). "SpaceX Completes $60 Billion Cursor Acquisition to Expand AI Coding Tools."
• 10.CNBC. (Jun. 16, 2026). "SpaceX to acquire the AI coding startup Cursor for $60 billion."

Research

• 11.Tang, N., Chen, C., Xu, G., Shi, Y., Huang, Y., McMillan, C., Dong, T., & Li, T. J.-J. (May 28, 2026). "How Coding Agents Fail Their Users: A Large-Scale Analysis of Developer-Agent Misalignment in 20,574 Real-World Sessions." arXiv:2605.29442.