Why Did OpenAI Pull the Plug on 2 Million Cursor Users?

One Acquisition, One Deadline, One Very Expensive Problem

On November 12, 2026, two million developers will wake up to find that the AI code editor powering their daily work has gone dark. Not because of a technical failure. Not because the product stopped working. Because of a business dispute between two of the most powerful men in technology, and a $60 billion acquisition that put Cursor squarely in the wrong camp.

Here is what happened. In June 2026, Elon Musk's SpaceX acquired Anysphere, the San Francisco startup behind Cursor, for approximately $60 billion. That single transaction changed who owned Cursor's parent company. And that, according to OpenAI, was enough. OpenAI announced it would cease supplying its AI models to Cursor on November 12, 2026, citing contractual violations by Musk's companies following the acquisition.

The stated reason sounds clean and procedural. The reality is messier. OpenAI has been locked in a bitter, public rivalry with Musk for years, a conflict that has moved through courtrooms, press releases, and competing product launches. The contract violation claim may be entirely legitimate. The timing, coinciding with Cursor's arrival inside Musk's commercial empire, makes it difficult to read as purely coincidental.

What makes this genuinely strange is the scale of the collateral damage. Cursor had $4 billion in annual recurring revenue and over two million active users by mid-2026 — developers who built their daily workflows around a tool that now has until November to find a new engine. A business dispute, dressed in the language of contractual obligations, has become a technical emergency for an enormous slice of the professional programming world.

From a Cambridge Dorm Room to a $29 Billion Valuation in Three Years

In 2022, four MIT students — Michael Truell, Sualeh Asif, Aman Sanger, and Arvid Lunnemark — decided that the code editor itself was the wrong unit of analysis. Not the models powering it, not the plugins bolted onto it. The editor. That conviction became Anysphere, and Anysphere built Cursor.

For the first two years, the outside world mostly ignored them. Then the numbers started arriving, and they were difficult to explain away.

In January 2025, Cursor's annual recurring revenue hit $100 million. By November of the same year, it had crossed $1 billion. That is a 10x in ten months — a growth rate that venture capital spreadsheets are not really designed to contain. The Series D valuation landed at $29.3 billion, with Accel, Thrive, NVIDIA, and Google among the backers. When NVIDIA and Google are both writing checks for the same developer tool, that is not enthusiasm. That is a considered bet on which layer of the stack will matter most.

By June 2026, ARR had reached $4 billion.

Roughly 36 percent of Cursor's free users converted to paid subscriptions. For context, most consumer software considers 5 percent a success. Cursor was doing this among professional developers, the most skeptical adopters on the planet — people who will tolerate friction in a tool before they will tolerate a tool that slows their thinking. That conversion rate meant Cursor was not a curiosity. It was becoming infrastructure.

The question worth holding is why. What did four students build that GitHub Copilot, with 26 million users and Microsoft's entire engineering weight behind it, had not quite managed to become?

The Feature That Made Developers Stay: Composer and the Whole-Codebase Trick

Ask a programmer what is wrong with most AI coding assistants and they will give you the same answer: the AI only sees the room you are standing in. It reads the file that is open, helps you fix that function, then forgets everything the moment you switch tabs. Real software is not one room. It is a house, with load-bearing walls you cannot move without cracking the plaster two floors up.

Cursor's answer to this was context indexing. On startup, the tool reads and indexes your entire codebase, so the AI reasons over the whole structure, not just the fragment in front of it. This sounds like a minor implementation detail. It is not. It means the AI can tell you that the function you are about to rename is called in fourteen other files, and then change all fourteen at once. That capability is Composer — Cursor's multi-file editing mode — and for a certain kind of developer, it feels less like autocomplete and more like a junior engineer who has actually read the codebase.

Here is the honest number: by June 2026, Cursor had over 2 million active users. GitHub Copilot, backed by Microsoft, has 26 million. That gap looks damning until you notice that Cursor built its user base in roughly three years, and that its users skew heavily toward professionals who write complex, production-grade code. The tool declared a "War Time" posture in early 2026, an internal signal that the product team recognized the pressure from new models shipped by both Anthropic and OpenAI. In that market, 2 million deeply loyal users spending serious money is not a consolation prize. It is a foundation.

OpenAI's Quiet Pivot: From Neutral Supplier to Direct Competitor

For most of its history, OpenAI played a comfortable role: the engine room, not the vehicle. Developers built products on top of its models, OpenAI collected the API fees, and everyone pretended this arrangement would last forever. Then, in October 2024, something quietly shifted. OpenAI launched Canvas, an interactive interface that let ChatGPT users edit and iterate on code directly inside the product. It was a small door, but it opened onto a very large room.

The moves came faster after that. In May 2025, OpenAI spent $3 billion to acquire Windsurf, a rival AI-powered code editor. That is not the behavior of a neutral supplier. That is a company that has looked at the developer tools market, recognized how much value is being captured one layer above its models, and decided it wants that layer for itself.

By February 2026, OpenAI had shipped Codex, a native macOS application aimed squarely at working programmers. The message to developers was plain: you can build on us, or you can use what we built. Then there is the raw capability argument. OpenAI's o3 model scored at the 99.8th percentile on Codeforces, a competitive programming platform that attracts some of the sharpest algorithmic minds on the planet. When you can point to a number like that, you do not need a sales pitch. The benchmark does the talking.

Each of these moves — Canvas, Windsurf, Codex, o3 — would be unremarkable alone. Together they describe a company walking steadily down the value chain, from foundational model to finished tool. Cursor's founders read this map as clearly as anyone. The question was whether they had moved fast enough before the road narrowed.

The Platform Trap: What Happens When Your AI Code Editor Sits on Someone Else's Land

There is an old rule in real estate that the three things that matter are location, location, location. In software, there is an equivalent: who owns the ground beneath you. Cursor built its house on OpenAI's land, and for three years, that was a perfectly rational choice. Then SpaceX bought the house, and OpenAI handed over an eviction notice.

This is not a new story. It has happened to developers who built on Twitter's API, on Facebook's platform, on Apple's App Store terms. Every generation of builders learns the same lesson at the cost of the generation before it. The AI era simply rewrote the eviction notice in a new language: a contract dispute, a corporate acquisition, a November deadline.

The structural vulnerability was always there. Cursor's entire model pipeline ran through OpenAI's API. That dependency was efficient and sensible right up until the moment SpaceX's acquisition moved Anysphere from "valued partner" to "rival camp" in OpenAI's ledger. The switch was not technical. It was relational.

Here is where the lock-in gets interesting. For two million developers, migration is not simply a matter of updating a configuration file. Cursor has indexed their codebases, learned their project structures, absorbed the shape of their workflows. That accumulated context lives inside a specific system. Moving means starting the relationship over, at real cost in time and attention.

The deepest form of vendor lock-in, it turns out, is not contractual. It is cognitive: the habits, the muscle memory, the invisible grooves worn into daily work by months of use.

November 12 Is Just a Date — the Real Questions Are Still Open

Nobody has seen the contract. The specific clauses OpenAI claims SpaceX violated remain undisclosed, which means the legal story is, for now, a headline with a locked room behind it. That is not a minor gap. The entire justification for cutting off 2 million developers rests inside that room.

The technical questions are equally open. Will Cursor, now sitting inside a $60 billion acquisition, attempt to build its own foundational models rather than lean permanently on Anthropic? Will 2 million users quietly absorb whatever cost increase a new model supplier brings, or will a meaningful fraction scatter toward GitHub Copilot's 26 million-strong ecosystem, toward Claude Code, or toward something not yet built?

Here is the honest answer: nobody knows. The numbers we have — $4 billion in ARR, a $29.3 billion valuation, a November 12 cutoff date — describe the shape of the cliff, not what lies at the bottom. Whether two million developers rebuild their workflows around a new coding assistant or scatter across a fractured market, November 12 is a deadline. What it inaugurates is still anybody's guess. And that, for anyone paying attention, is precisely where the next interesting story starts.