OpenAI Cut Cursor Off Over Its New Owner. Your Own API Key Doesn't Reach the Background Agents.
On 28 August OpenAI notified SpaceX that it intends to wind down the contract supplying OpenAI models to Cursor, with a proposed shutoff on 12 November. SpaceX had closed its all-stock acquisition of Anysphere, Cursor's parent, two weeks earlier at an implied equity value near 60 billion dollars. The clause that fired was change of control.
Nothing Cursor built triggered it. No usage violation, no rate abuse, no deprecation notice, no model retirement. A line in a commercial agreement went live because the cap table moved.
The part worth your attention is the escape hatch. You can plug a personal OpenAI key into Cursor and keep using GPT models, and that route covers local Chat and Agent sessions. It does not cover Cursor Tab, Auto routing, Cloud or Background Agents, Automations, the Cursor CLI, or Cursor's own API and SDK.
What happened
OpenAI's agreement with Anysphere carried a termination right that opens for a limited window after an ownership change. SpaceX completed the Anysphere purchase on 14 August. OpenAI sent notice on 28 August, inside that window, and says it gave the maximum contractual notice period.
The stated reason is not technical. OpenAI's Thibault Sottiaux put it as trust, and the company pointed at a history with Musk's other businesses: the termination of OpenAI's Twitter data access in December 2022, worth roughly two million dollars a year, and the use of competitor model outputs to train Grok in violation of terms. OpenAI was explicit that this is about the new owner and not about coding tools generally.
Michael Truell, Cursor's co-founder, said OpenAI models account for about five percent of Cursor's AI traffic, that Cursor was one of OpenAI's earliest customers, and that his company had trusted OpenAI to be neutral infrastructure. He said the two teams are talking. The 12 November date is proposed rather than final, and Cursor can also end access sooner if it chooses.
Anthropic moved inside a day. Tom Brown said Anthropic would expand compute capacity for Claude models inside Cursor, and Claude usage limits in the product went up. Google's models were never in scope. Grok landed in Cursor on 26 August, two days before the notice, from a model lab that now sits on the acquirer's side of the house.
The escape hatch has a shape
Three routes survive the cutoff, and each one is narrower than it first looks.
Bring your own key works in local Chat and Agent sessions, billed at OpenAI API prices. OpenAI's own support documentation names the surfaces where it does not work, and that list is the story: Cursor Tab and autocomplete, Auto model routing, Cloud and Background Agents, Automations, the Cursor CLI, and Cursor's API and SDK.
The Codex extension runs inside the Cursor window as a separate agent panel, which is a different product sharing a screen rather than a model restored to the one you were using.
An AI gateway in front, Bedrock or Azure or OpenRouter, moves the billing relationship but does not change which Cursor surfaces will accept a key you supply.
Read the exclusion list again and notice what it has in common. Every excluded surface is one that runs without a person watching it. Tab fires on a keystroke you did not think about. Background Agents run on Cursor's machines while you are asleep. Automations run on a schedule. The CLI and SDK run inside somebody's pipeline.
The rescue path covers the chat pane. The autonomous half of the product is exactly the half a personal key cannot reach.
Why a key cannot travel into a background agent
This is architecture, not policy, and it is worth being precise about because the same shape will show up in every tool you depend on.
A key you paste into your editor is a client-side credential for an interactive session. The request originates on your machine, in a process you started, for work you are watching. That is a straightforward thing for a vendor to pass through.
A background agent is not that. It runs on Cursor's infrastructure, in Cursor's process, under Cursor's account, against Cursor's supply contract. Tab is the same story at a different latency budget. So is Auto, which is a router making the model choice for you server-side. For any of those to carry your key, the vendor would have to hold your credential, use it on your behalf in a loop you are not present for, and take on the liability for what it does there.
That is the integration surface OpenAI is severing. The wind-down is a decision about Cursor as a customer, and traffic that leaves Cursor's servers is Cursor's traffic regardless of whose key is stapled to it.
Which gives a rule that generalises past this one incident. In any agent product, the features you can rescue with your own credentials are the features where you are the one pressing the button. The features that make it an agent product are the ones where you are not, and those inherit the vendor's supply relationships whether you like it or not.
Five percent is the number that saved them
The reason this is survivable for Cursor is a router built for the wrong reason.
Multi-model routing in coding tools was built to arbitrage cost and quality. Send the cheap edits to the cheap model, send the hard reasoning to the expensive one, keep the flagship for the cases that need it. That work was done for margin.
It turned out to be insurance. When the supply cut came, the exposed surface was five percent of traffic, and a competitor covered it within twenty four hours. If Cursor had been a GPT-only product in 2024, 28 August would have been an extinction event instead of a support article.
That hedge was a side effect. Routing got built for margin and paid out as continuity, which is not what the design doc said it was for. If your agent stack still names one model in one place, the cheap version of this lesson is to add a second one now and push real traffic through it, so you find out what breaks while it is still optional.
The uncomfortable part
Model portability is getting harder at the exact moment it stopped being optional.
xAI trained Grok 4.5 alongside Cursor, tuned inside one agent's loop and tool format. Cursor ships Composer, its own model, in its own harness. That direction produces better numbers and worse substitutability, because the thing you are swapping is no longer an API call, it is a model plus the prompt scaffolding, tool schemas and retry behaviour that were tuned together.
Swapping providers is a schema change. Swapping harness assumptions is a rewrite, and it will not announce itself in an error log. It shows up as an agent that still runs, still returns, and quietly gets worse at the work.
The practical answer is boring and it is the same one that has worked for every other dependency. Keep an eval harness that runs your real tasks, not benchmarks, against every model you might have to fall back to. Run it monthly. When a clause you never read fires on a Friday afternoon, the question is not whether you can point at a different endpoint. It is whether you already know what happens when you do.