Rohit Ghumare · August 29, 2026 · 9 min read

OpenAI Cut Cursor Off. Five Percent Is the Interesting Number.

On August 28, OpenAI told SpaceX it will wind down the contract that puts OpenAI models inside Cursor, with a proposed shutoff of November 12, 2026, the longest notice the contract allows. Cursor's CEO answered the same night: "OpenAI models serve about 5% of Cursor user traffic." Most of the coverage read that number as a shrug. Read it as an engineering fact instead. A coding harness with roughly $2.6 billion in annualized revenue, as CNBC reported in June, had already turned its most famous model vendor into a minority dependency, and a cutoff notice is the cleanest test of a harness there is. The 95% does not notice. The 5% tells you exactly which parts of the machine were built around one vendor.

What was cut, and what was not

Precision matters here, because three different things get called "OpenAI in Cursor" and only one of them is ending. The first is the platform contract: a custom agreement under which Cursor buys OpenAI capacity at scale and resells it inside its own product. That is what OpenAI is cancelling. Its post says the deal "gives us a limited time window to cancel it after a change of control," that the company is "giving the maximum notice provided by our contract," and that it will not provide future models to Cursor while the wind-down runs. The stated reason is trust, not technology: OpenAI writes that it "cannot be confident that SpaceX will use our technology within our terms of service," and points at Twitter breaking a data contract in 2023 and at Musk's April 2026 testimony that xAI had violated OpenAI's terms by distilling its outputs.

The second path is the user's own API key. OpenAI's Thibault Sottiaux said on X, as quoted by The Decoder, that people who bring their own OpenAI key to Cursor keep working, and that OpenAI will keep shipping its own IDE extension for Cursor. That is the third path: OpenAI's Codex extension running inside Cursor's editor, which is OpenAI software talking to OpenAI servers and never touched the contract at all.

So the cutoff is narrower than the headline and wider than a product change. It removes one licensed capacity pipe. It leaves the individual-key pipe and the vendor's own extension. The reason that distinction matters for anyone building a harness is that the pipe being removed is the one you cannot see from the code. It is a clause.

Notice which row costs Cursor money and which rows cost the developer money. The row that ends is the one where the harness was the customer. The two that survive are the ones where the developer is. That is not an accident of this contract. It is what a platform deal is: the harness buys wholesale so its users do not have to, and wholesale comes with terms that retail does not.

The clock

The dates are worth laying end to end, because the mechanism is a calendar. SpaceX announced the all-stock deal on June 16. It closed on August 14, per the SEC filing CNBC cites. OpenAI's notice landed on August 28, fourteen days after the close, inside whatever window the change-of-control clause opened. The proposed shutoff is November 12, seventy-six days after the notice. A contract clause with a window is a timer, and OpenAI used both ends of it: the earliest it could act, and the latest date it could name.

Why five percent

Cursor is a harness in the sense I used in The Harness, Not the Model: the software that holds the context, owns the tools, gates permissions, runs the loop, and picks which model gets each call. The one axis in that essay that matters today is portability. A first-party harness is usually locked to its maker's models. A model-agnostic one treats the model as a swappable part behind an interface. Cursor was built model-agnostic because it started as an editor that borrowed everybody's models, then added its own Composer line, and its parent now also owns Grok. Anthropic's Tom Brown posted that Cursor "has been a trusted partner of Anthropic since Sonnet 3.5" and that Anthropic will "continue to increase compute to support Claude models in Cursor," which tells you where the bulk of the other 95% already goes.

That is the whole reason a cutoff notice reads as a footnote. Not because OpenAI's models stopped mattering, but because Cursor had already done the engineering that makes any single vendor removable: an adapter per vendor's tool-calling format, a router that assigns models per feature, its own evals, its own prompt-cache strategy. The same work that keeps the bill manageable across vendors is the work that makes a vendor cutoff survivable. Portability is not a feature you add for cutoffs. It is a property you already have if you took cost seriously.

The people this hurts are, as OpenAI's own post admits, "the developers who rely on OpenAI models in Cursor." For them the fix is the second pipe: a personal key. For Cursor the fix is the router. For everyone else the lesson is an audit, because the 5% is only small if your harness is built like Cursor's.

What a cutoff actually breaks

Say your harness hard-coded one vendor and that vendor sends you a notice tomorrow. What fails on shutoff day is not "the model." It is every surface where the vendor's shape leaked into your code. There are eight of them, and they fail in different ways.

Tool-call schema. OpenAI returns tool invocations as tool_calls entries with a JSON-encoded arguments string. Anthropic returns tool_use content blocks with a structured input object. Gemini uses functionDeclarations and functionCall parts. A harness that parses one of these inline fails to parse the others, so every tool call from the fallback model dies before it runs. Streaming. OpenAI streams choices[0].delta chunks; Anthropic streams typed events like content_block_delta. A parser written to one shape renders nothing on the other. Prompt caching. OpenAI caches long prefixes automatically. Anthropic wants explicit cache_control breakpoints. Gemini has explicit cache objects with a lifetime. A harness that only ever relied on automatic prefix caching pays full prefill on every turn of the fallback until someone adds the breakpoints, and I showed in the Codex teardown how large that re-prefill bill gets on a long transcript. Token accounting. Tokenizers differ, context limits differ, and a budget computed with one vendor's counts overflows or under-fills the other. Evals. A pass rate tracked for one model says nothing about the model you switch to. Prompts. A system prompt tuned to one vendor's quirks is read differently by the next, silently. Routing. A model id hard-coded per feature means the affected requests error until a deploy. Keys. No bring-your-own-key path means the users who wanted that vendor lose it entirely instead of paying for it themselves.

Run the audit on the two archetypes and the shape of the result is the point. The first-party archetype scores near zero and breaks on seven surfaces at once, which is what "locked to its maker's models" means in practice. The model-agnostic archetype scores full and its shutoff-day list is empty: the notice becomes a config change and a capacity conversation. Most real harnesses sit in the middle, and the middle is where a cutoff hurts, because two or three broken surfaces are enough to take a product down while looking, in the router, like a five percent problem.

Re-routing the five

Once the surfaces are abstracted, the remaining work is capacity and choice. Five requests out of every hundred need a new home, and the harness gets to pick from whatever lineup it already drives. Cursor's realistic lineup is public: Composer, its own model family, which SpaceXAI also lists as available inside Grok Build since June; Grok 4.6 from the same parent; Claude from Anthropic, whose compute pledge above is the only public statement of extra capacity; and Gemini from Google. Moonshot's Kimi K3 and other open-weight models are a phone call away for any harness that speaks an OpenAI-compatible endpoint. The re-route is arithmetic once the adapters exist.

Uncheck every fallback and the five cells simply die, which is the honest picture of a harness with a hard-coded model id. Check one and they all land on it, which is the picture of a harness with a fallback but no choice. Check three and the router has options, and the question becomes which of the three passes your evals for the features those five requests were using. That last step is where the per-model eval suite from the audit earns its keep. Routing without evals is guessing with extra steps.

There is a second half to a re-route that no figure on this page can show, and it is capacity. A router can only send traffic to a vendor that has agreed to take it, at a rate limit that has agreed to grow. That is why Tom Brown's post was written the way it was. "Continue to increase compute" is not a sentiment, it is the term that makes the other 95% possible, and it is a term the vendor can revise. The five percent moves today because Anthropic, SpaceXAI, and Google each want it. On a different week, with a different acquirer, one of them might not, and a harness that only ever negotiated with one vendor would discover that adapters alone do not route requests. Contracts do.

Neutral infrastructure does not exist

Cursor's CEO wrote that his company had "trusted their platform to be neutral infrastructure for our business." That is the sentence to keep, because it names the belief the whole industry is now correcting. A frontier model behind a commercial API is not neutral infrastructure the way TCP is. It is licensed capacity from a company with its own products, its own competitors, and a legal team that writes change-of-control clauses for exactly this week. The precedents are not subtle. In June 2025, Anthropic limited Windsurf's access to Claude after reports that OpenAI was buying Windsurf, per TechCrunch. In August 2025, Anthropic revoked OpenAI's own API access over benchmark use, as The Decoder recounts. Every vendor has the switch. Every vendor has used it. Tom Brown's post drew replies from Replit's Amjad Masad and Docker's Mat Velloso reminding him of Windsurf, and the replies were fair.

The only layer that can be neutral is the one you own. That is the harness, and it is neutral exactly to the degree that the model is a swappable dependency inside it. The audit above is the checklist. To it, add one item that no code review catches: if you are the company being acquired, read the change-of-control clauses in your model contracts before the deal is announced, and count the notice windows. The fourteen days between Cursor's close and OpenAI's notice were not a coincidence. They were a term.

What to do this week

• Put one internal tool-call type between your loop and every vendor SDK. Adapters are boring and they are the difference between a config change and an outage.
• Keep an ordered fallback list per capability, not a model id per feature. Route by what the request needs, then by who is available.
• Run the same eval set against every model in the list on a schedule, and set a floor. A fallback that fails evals is not a fallback.
• Write cache breakpoints per vendor now, while the bill is calm. Re-prefill on a long transcript is the cost you notice on day two of a migration.
• Offer a personal-key path. It is the pipe that survives the contract.
• Reread the contract. The clause is the mechanism.

Five percent was small because Cursor built for it. The number to worry about is not the share on the vendor that just left. It is the number of surfaces in your harness that would break if any of them did.