Anysphere · Alternatives
Cursor alternatives: sorted by what you are actually leaving
People rarely leave Cursor for a smarter agent. They leave because nobody can tell them what a plan includes, because their own key still runs through the vendor's servers, because they wanted a terminal or their own IDE, or because a team seat costs twice an individual plan. Each reason has a different shortlist, and one of the closest alternatives runs inside Cursor's own editor.
Why people actually leave this one
The allowance has no published size
Every request is billed in dollars at list price, but how many dollars a plan includes is no longer written anywhere: the upper tiers are sold as three and twenty times Pro, and the documentation column that sized each plan was removed at the start of September. For a budget owner that turns a subscription into a meter with an unknown tank. The alternatives that publish their allowance as an amount, or that have no allowance at all because you pay per token, answer this directly.
Your own key still goes through their servers
Bringing an API key changes who bills the tokens, not who sees them. The vendor states that requests on your own key still pass through its backend to build the final prompt, that its zero-retention agreements do not apply to them, and that on team plans each third-party request on your key still carries a per-token platform fee. For a personal account, the default of the setting that governs training is not stated in any document we read.
You wanted a terminal, or to keep your own IDE
Cursor is an editor first. There is a command-line client, and JetBrains IDEs can reach the agent over the Agent Client Protocol through JetBrains' own AI Assistant plugin, but the product's centre of gravity — Tab, the diff review, the agents window — lives in a VS Code fork you have to adopt. People whose day runs in a terminal, over SSH or in a CI job reach for tools built there.
A team seat costs twice an individual plan
The Standard seat is double the entry individual plan, the Premium seat triples that, and on either one every third-party request carries a platform fee on top of the model's price — including requests on the team's own keys. On-demand spending is on by default, too. For a team that mostly wants autocomplete and chat, several alternatives charge less per head, and one charges nothing.
If you only read one line.
GitHub Copilot
The answer to the unsized allowance. GitHub prints each plan's monthly credits as a dollar amount, split into a base equal to the price and a variable top-up, works in almost every editor rather than one, and starts at half Cursor's entry price.
Cline
The answer to the data path, without leaving the editor: it runs as an extension inside Cursor itself, as well as VS Code and JetBrains, and sends requests from your machine straight to the provider you choose. Its own terms exempt that arrangement from their content licence unconditionally.
Claude Code
The answer for the terminal. It lives where the shell does, runs unattended in CI, and on the neutral agent index our comparison uses it scores well above Cursor's own CLI — at a noticeably higher cost per task, which the pair lays out.
Every alternative we checked.
Grouped by the reason for leaving, not ranked. The first four rows keep an editor and change the terms; the last four trade the editor for a terminal, an extension or a free client. Competitor prices are the vendor's own, read on the date beside each row; our own tools link to their hubs instead.
An assistant and agent that plugs into the editor you already use, sold on plans whose monthly credits are stated in dollars.
It publishes exactly what Cursor withdrew. Each paid plan's monthly allowance is printed as a dollar amount of credits, made of a base equal to the plan's price and a flex top-up above it, with the option to buy more. It runs in VS Code, Visual Studio, JetBrains IDEs, Eclipse, Xcode and Neovim, so nobody has to change editors, and the entry plan costs half of Cursor's.
Tradeoff: the flex part of the allowance is described as variable and liable to change, so only the base is a firm number. The editor loop is shallower than a product that owns its editor, and the free tier caps completions and chat by count.
Best for: knowing what the plan includes before you pay.
The other big VS Code fork with an agent built in, renamed from Windsurf and now sold under Cognition's Devin brand.
The closest like-for-like swap. The free plan includes unlimited Tab completions and unlimited inline edits alongside a light agent quota, and the paid ladder mirrors Cursor's at the entry and top individual tiers. It runs the same frontier models, and our pair found it ahead on autocomplete terms and deployment options.
Tradeoff: its team plan adds a monthly team fee on top of the per-seat price, so small teams pay more per head than on Cursor, and there is no middle individual tier. The product has already been renamed once this year.
Best for: the same shape of product with autocomplete never on a meter.
Google's agent-first IDE, generally available and free for individuals, with paid rate limits through Google AI plans.
The individual plan costs nothing and is not a trial: agent access to several Gemini models, Claude Sonnet and Opus and an open-weight model, unlimited Tab completions and unlimited command requests, under weekly rate limits. On the neutral agent index our comparison uses, Google's harness scores above Cursor's CLI at a lower cost per task.
Tradeoff: free has a shape. The limits refresh weekly and are described rather than numbered, raising them means a Google AI subscription or a Google Cloud contract, and our pair found no bring-your-own-key route. Teams go through Google Cloud rather than a self-serve seat.
Best for: an agent IDE with no subscription at all.
The open-source editor Cursor is forked from, with agent mode and bring-your-own-key chat of its own.
Everything underneath Cursor, without the subscription. The editor is free, agent chat can run on your own key, and the extension marketplace — including the free agents further down this list — works the same way. If what you valued in Cursor was the editor rather than its house models and autocomplete, this is the smallest possible move.
Tradeoff: no house model, no tuned agent loop and no autocomplete of the same kind unless you add a Copilot plan. You assemble what Cursor ships ready-made, and you maintain the assembly.
Best for: keeping the editor and paying only for tokens.
A free Apache-2.0 coding agent that runs as an extension in VS Code, JetBrains and Cursor itself, on whatever model you point it at.
The one alternative you can try without leaving Cursor's editor, since it installs there as an extension. On your own key the request goes from your machine to your provider, with no platform fee and no subscription in between, and a local model through Ollama or LM Studio removes the network entirely. There is no allowance to size because there is no allowance.
Tradeoff: no Tab autocomplete, which is the feature many people came to Cursor for. And read its terms before its cheapest routes: they take a licence over your content except on your own key through your own infrastructure or on a per-seat enterprise deal.
Best for: taking the vendor out of the request path.
Anthropic's terminal coding agent, sold inside the Claude subscription or billed per token on an API key.
A different shape of tool rather than a cheaper editor: it runs where the shell does, drives git and test suites directly, and runs unattended in pipelines. On the neutral agent index our pair relies on it scores clearly above Cursor's CLI. It is also the only tool in this section we have run ourselves, so its pages rest on more than documents.
Tradeoff: one vendor's models, no editor of its own and no autocomplete, and a much higher cost per task on the same index. Its allowance is stated as multiples of a plan as well, so it does not solve the budgeting complaint.
Best for: work that lives in a shell, over SSH or in CI.
OpenAI's coding agent, in the terminal, an IDE extension and the cloud, included with ChatGPT plans.
Our pair found it the stronger agent by a wide margin on the neutral index, and the cheaper subscription to reach it, since limited access rides on ChatGPT plans below Cursor's entry price. If the reason you are leaving is results rather than money, this is the row with the largest measured difference.
Tradeoff: it meters in credits that OpenAI never prices in money, which is less transparent than Cursor, not more. It also costs many times as much per task on the same index, and it runs OpenAI's models only.
Best for: the strongest agent on the index, if you already pay OpenAI.
An MIT-licensed terminal agent whose vendor sells model access at per-token rates it publishes openly.
The budgeting complaint answered from the other side: no subscription allowance to guess at, a published per-token card for the vendor's own gateway — which our snapshot checked and found accurate on nearly every row — and a flat plan whose ceiling is stated in dollars of usage. Your own key and local models work too.
Tradeoff: it lives in the terminal. No editor, no diff view beside your code and no autocomplete — if Cursor's appeal was the editing surface, this removes exactly that.
Best for: a free client with the prices written down.
Pick by what you're doing.
Finance will not approve a plan it cannot size
Your manager wants to know what each developer's subscription includes before signing, and “three times Pro” is not an answer.
GitHub Copilot
It is the vendor on this list that prints the allowance as money: a base credit equal to the plan's price, plus a variable top-up, per plan, on its own pricing page. That gives finance a floor per seat before anyone installs anything. The alternative is to stay and cap the risk yourself — keep on-demand usage off, which on individual plans is already the default.
Security says the code may not pass through a third party
Your review accepts your model provider, but not an extra company building prompts in between, and a platform-side privacy toggle is not enough.
Cline
On your own key it sends requests from your machine to your provider directly, which is the arrangement Cursor's own documentation says it does not offer. Cline's terms exempt that route from their content licence without conditions, and a local model removes the provider too. You can try it inside the Cursor editor before deciding anything else.
The work happens in a terminal, not an editor
Your team runs agents over SSH, inside CI jobs, or against repositories nobody opens in a GUI.
Claude Code
It was built for exactly that and runs unattended in pipelines. Our comparison found it scoring clearly above Cursor's own CLI on the neutral index, at a higher cost per task. If the budget cannot take that, the free terminal client with published per-token rates is the next row to read.
There is no budget at all
A student, a side project or an evaluation where no one will approve a subscription.
Google Antigravity
The individual plan is free and generally available rather than a trial, with agent access to several frontier models and unlimited Tab. Cursor's own free tier is real too, but its limits are unnumbered; Google's are weekly and also described rather than numbered, so neither lets you plan a month in advance. Try both on the same task.
When staying put is the right call
Frequently asked.
What people search next.
Q · 01 What is the best free alternative to Cursor? +
It depends on what free has to include. Google Antigravity's individual plan costs nothing and includes an agent, Tab and several frontier models under weekly limits. Visual Studio Code is free and can run agent chat on your own key, so you pay only for tokens. Cline and opencode are free clients that charge nothing themselves and send requests to a provider you choose, or to a local model. Cursor's own Hobby tier is free too, with limits it does not number.
Q · 02 Is GitHub Copilot cheaper than Cursor? +
At the entry level, yes: its first paid plan costs half of Cursor's, and its team seat is also cheaper per head. It also publishes each plan's monthly credits as a dollar amount, which Cursor stopped doing in September. Cursor's advantages are the depth of its editor loop and its own models. Our comparison of the two lays out both allowance systems row by row.
Q · 03 Is there an open-source alternative to Cursor? +
Several. Visual Studio Code, the editor Cursor is forked from, is open source. Cline is Apache-2.0 and runs as an extension in VS Code, JetBrains IDEs and Cursor itself. opencode is MIT and runs in the terminal. None of them is a like-for-like replacement — none ships a house model or Cursor's autocomplete — but each lets you read the client you run.
Q · 04 What happened to Windsurf? +
It is now Devin Desktop, owned by Cognition; the old pricing address redirects to Cognition's site. The product is still a VS Code fork with an agent, and its free plan includes unlimited Tab completions. Our comparison with Cursor still carries the Windsurf name because that is what most people search for.
Q · 05 Can I use a different agent inside the Cursor editor? +
Yes. Cursor runs VS Code extensions, and Cline documents Cursor among the editors its extension supports. That lets you keep the editor, its autocomplete and your settings while sending agent work to a provider of your choice on your own key — useful when the objection is the data path rather than the editor.