Cursor is a code editor built by Anysphere on the open-source core of VS Code, with AI wired into the editing loop: Tab predicts your next edit across lines and files, Inline Edit rewrites a selection, Agent works across a whole task, and Plan mode researches before it writes. It imports your VS Code extensions, settings, and keybindings. It runs its own models alongside Claude, GPT, and Gemini. Hobby is free and Pro is $20 a month as of August 2026.
- It is a VS Code fork, not an extension. Settings and keybindings import.
- Tab is the differentiator: multi-line, cross-file, next-location prediction.
- Cursor 2.0 and 3.0 moved the centre of gravity from files to agents.
- Extensions install from Open VSX, not the Microsoft marketplace.
- Hobby is free and Pro is $20. Cursor does not publicly publish prices for Pro Plus or Ultra as of August 2026.
The short version
Cursor is a code editor made by Anysphere. It is built on the open-source core of Visual Studio Code, so it looks like VS Code, uses VS Code keybindings, and reads VS Code settings. The difference is that the AI is not a panel bolted to the side. It is wired into the editing loop itself, which is why the experience is not reproducible with an extension.
You interact with it in four ways, and choosing between them correctly is most of the skill.
| Surface | What it does | When it shines |
|---|---|---|
| Tab | Predicts your next edit, including elsewhere in the file and in other files | Repetitive edits and refactors you are steering |
| Inline Edit | Select code, describe a change, review the diff in place | A focused change you can point at |
| Agent | Multi-file work, runs commands, drives a browser, iterates | Whole tasks you can describe but not point at |
| Plan mode | Researches the codebase and writes a reviewable plan before touching code | Anything you would want a design review on |
Accept a suggestion with Tab. Reject it with Escape, or just carry on typing. You can take a suggestion a word at a time with Cmd and Right Arrow on macOS, Ctrl and Right Arrow on Windows and Linux, which is the control most people never find and then use constantly.
Which models it runs
Cursor is unusual among editors in that it both trains its own models and resells everyone else's. As of August 2026 that splits into two pools, and the split is also how the billing works.
From the Cursor pricing reference, checked August 2026.
| Pool | Models | How it is billed |
|---|---|---|
| Cursor Models | Composer 2.5 and Cursor Grok 4.5 | Generous included usage on every paid plan |
| Other Models | Claude, GPT, and Gemini families | A dollar allowance per plan, then on demand at API rates |
| Auto | Cursor picks the model for you | Included, and exempt from the Teams token surcharge |
| Tab | Cursor's own completion model | Unlimited on Pro, Pro Plus, and Ultra |
Composer is the interesting one. Cursor trained it for the agent loop its editor cares about rather than for benchmark scores. Anysphere's claim when it launched with Cursor 2.0 on 29 October 2025 was that Composer is four times faster than similarly intelligent models and completes most turns in under thirty seconds. In practice that is the difference between an agent you watch and an agent you walk away from, and it changes how you use the tool more than a few benchmark points would.
What Cursor 2.0 and 3.0 changed
If you last looked at Cursor before late 2025, you looked at a different product. Two releases moved the centre of gravity from files to agents, and most out-of-date reviews are stranded on the wrong side of them.
From the Cursor changelog and release posts, checked August 2026.
| Release | What it introduced |
|---|---|
| Cursor 2.0 (29 October 2025) | The Composer model, a multi-agent interface, parallel agents isolated by git worktrees or remote machines, and a browser tool the agent uses to check its own work |
| Cursor 3.0 (2 April 2026) | The Agents Window, Design Mode for annotating UI elements in the browser, agent tabs side by side or in a grid, an Await tool for background commands, plus the /worktree and /best-of-n commands |
| Alongside those | A standalone CLI with print mode, an OS sandbox, and a documented GitHub Actions recipe |
/best-of-n is worth understanding even if you never use it, because it tells you what Cursor believes. It runs the same task across several models in parallel, each in its own isolated worktree, and lets you pick the winner. That is a bet that inference is cheap and your review time is the scarce resource, which is the same bet behind everything else in the agent-first redesign.
The fork tax nobody mentions
Almost every article says your VS Code extensions carry over. That is mostly true and materially incomplete, and it is the most common unpleasant surprise for people switching.
Cursor does not install from the Microsoft Visual Studio Marketplace. Its documentation states that Cursor uses the Open VSX extension registry for third-party extensions, with a Cursor marketplace proxy running automated malware and supply-chain analysis before an extension is offered for install. It also publishes first-party Anysphere replacements for some widely used extensions that are not on Open VSX.
The great majority of extensions are published to both registries. The ones that are not are disproportionately Microsoft's own, because Microsoft restricts several of them to its own products. So the migration risk is concentrated in a short, checkable list.
Check these against Open VSX before you migrate a team, not after.
| If your day depends on | Do this first |
|---|---|
| Python with Pylance | Check what Cursor offers for Python language support and try it on a real repository for a week |
| C# and .NET tooling | Check the C# extension situation specifically. This is the highest-risk stack for a Cursor migration |
| Remote development over SSH | Check which remote extension Cursor ships and whether it reaches your hosts |
| Real-time pair programming | Confirm an equivalent exists before you promise one to your team |
| Anything else | Search Open VSX for it. Most things are there, and the import flow tells you what did not come across |
Where it sits against the alternatives
Entry prices checked August 2026.
| Cursor | Copilot in VS Code | Claude Code / Codex | |
|---|---|---|---|
| Shape | AI-native editor | Extension | Terminal agent |
| Best at | Editing code you are reading | Completion in your existing setup | Whole delegated tasks |
| Multi-file work | Yes, Agent | Yes, agent mode | Yes, natively |
| Parallel sessions | Yes, worktrees built in | No | Yes, with worktrees you create |
| Runs in CI | Yes, via the CLI | Via the Copilot coding agent | Yes, mature |
| Extension registry | Open VSX | Full Microsoft marketplace | Not applicable |
| Entry price | $20/mo | $10/mo | $20/mo |
| Free tier | Yes, Hobby | Yes, limited | No |
The useful framing is not which is best but which hour of your day it addresses. Cursor makes the time you spend in code faster. A terminal agent removes some of that time entirely. Those are complements, which is why so many people pay for one of each, and why comparison articles that declare a winner are answering a question nobody asked.
Switching from VS Code
Install, then run the import
Open Cursor Settings with Cmd or Ctrl and Shift and J, go to General then Account, and click Import under VS Code Import. That moves extensions, themes, settings, and keybindings in one action. Then check the two or three extensions you rely on most actually came across.
Learn Tab first, for a week
Accept its suggestions even when you would have typed something slightly different. Tab feels like autocomplete for about two days and then starts predicting the edit you were about to make. That transition is the entire value proposition, and judging it on day one judges the wrong thing.
Then Inline Edit
Use it on a change you could describe in one sentence and point at with your cursor. If you can point at it, this is faster and safer than the agent, because the blast radius is the selection.
Write one rules file
A single short file under .cursor/rules/, or an AGENTS.md at the root, holding the conventions you would otherwise repeat in every prompt. Committing it means every agent run in the repository starts from the same place.
Try Plan mode before Agent
Shift and Tab from the chat input rotates into Plan mode. Reading a plan costs a minute and routinely saves an hour of reviewing a diff that went the wrong way.
Who it is not for
- People who live in vim or JetBrains. The value is in the editor, and switching editors is a real cost that a plugin does not impose.
- Teams pinned to Microsoft-only extensions. See the section above. Evaluate before you migrate, not after.
- People who mostly delegate. If you describe a task and review a diff, a terminal agent covers that shape natively, and you would mostly be paying for a Tab you rarely press.
- Teams with strict data policies that have not evaluated it. Cursor documents a privacy mode; route that claim through your own review process rather than through a paragraph on a guide.
Questions people ask
A code editor built by Anysphere on the open-source core of VS Code, with AI in the editing loop: Tab predicts your next edit across lines and files, Inline Edit rewrites a selection, Agent works across a whole task, and Plan mode researches before it writes.
No. It is a fork, which lets it change the editing experience itself rather than adding a panel. Tab prediction is the clearest example and is not something an extension can replicate.
Most do. Cursor installs from the Open VSX registry rather than the Microsoft marketplace, and publishes its own Anysphere replacements for some widely used extensions that are not on Open VSX. Check the handful you depend on before migrating a team.
Cursor's own model, trained for the agent loop rather than for benchmarks. Cursor claimed at launch that it is four times faster than similarly intelligent models and completes most turns in under thirty seconds. It sits in the included Cursor Models pool alongside Cursor Grok 4.5, not in the metered third-party pool.
For editing code you are actively reading, most people find Tab noticeably better. Copilot is cheaper at $10, lives inside the editor you already use, and keeps the full Microsoft extension marketplace.
They address different hours. Cursor makes time spent in code faster; a terminal agent removes some of that time entirely. Many people pay for both, and Cursor now ships its own CLI if you want the terminal shape on the Cursor account you already have.
There is a free Hobby tier with limited agent requests and no credit card. Pro is $20 a month; Cursor does not publicly publish prices for Pro Plus or Ultra as of August 2026. The free year for students closed to new sign-ups on 25 June 2026.
Cursor 2.0, on 29 October 2025, introduced the Composer model, parallel agents isolated by git worktrees, and a browser tool. Cursor 3.0, on 2 April 2026, added the Agents Window, Design Mode, agent tabs, and the /worktree and /best-of-n commands. Reviews written before those releases describe a different product.
Sources
Every figure above was read from these pages on August 2026. Vendors reprice without notice; if you find a stale number, tell us.