How to Switch to Cursor 2.0 and Run Agents Safely
Cursor 2.0 keeps the VS Code fork and adds a native agent view where multiple agents run in parallel on the same repo. You update in place — the app self-updates and imports your settings, extensions and keybindings — but the defaults for how much an agent can do on its own changed, so the first thing to adjust is permissions.
This guide covers the upgrade path, the model choices that matter, and the guardrails I use on a real codebase rather than a demo one.
What is different in Cursor 2.0?
The headline is not a new model — it is the agent workspace. Instead of a chat pane that edits one file at a time, Cursor 2.0 shows a task list where several agents can work in separate worktrees. One agent refactors the API layer while another writes tests against the old behaviour.
The Composer model was retrained for this multi-file loop and runs noticeably faster on iterative edits. Context windows are large enough for a mid-sized package, but not for an entire monorepo, so scoping still matters.
Pricing did not collapse. The Pro plan stays at $20/month with a monthly request allowance; heavy agent users end up on Pro+ or Ultra because parallel runs burn through usage faster than single-file edits ever did.
How do you migrate from Cursor 1.x without losing settings?
Update from the app’s internal updater, not by downloading a fresh install. A clean reinstall keeps the code but drops custom keybindings and some extension settings.
After the update:
- Open settings and check that your
.cursorrulesfile is still recognised. It is. - Review Settings → Agents → Terminal access and set it to ask before every command, at least for the first week.
- Check your default model — the upgrade may reset it to the new default Composer model.
- Re-open each workspace once, so the index rebuilds. The first re-index on a large repo took 6 minutes in my test.
If a workspace feels slow after upgrading, delete its .cursor/index folder and let it rebuild. Stale indexes from 1.x are the usual cause.
How do you stop an agent from breaking things?
Three layers, and you want all three.
Layer one: permission prompts. Keep terminal commands and file deletes on “ask”. Auto-run is faster and I do not use it on repos with production secrets in .env.
Layer two: git. Commit before every agent run. The agent’s changes are then a diff you can revert in one command. This is the single habit that makes agents tolerable.
Layer three: a scoped task. Give one file or one folder per agent. “Refactor src/api/client.ts to use retries” produces reviewable output. “Improve the codebase” produces a 400-line diff you will throw away.
Cursor 2.0 shows a diff per agent before you accept it. Read the diff. Accepting without reading is how people end up with a rewritten auth module at 2 a.m.
Composer or Apply: which one should you use?
Composer is for multi-file work where you want the agent to plan. Apply is for editing selected code in place. If your change touches one function, Apply is faster and easier to review.
Parallel agents sound better than they are for small tasks. Orchestration overhead — worktrees, merging, resolving conflicts — dominates when each task is 20 lines. Parallel runs start paying off when you have three genuinely independent workstreams, such as a backend change, a frontend change and a test suite.
What are the real limits?
- Pro’s monthly request allowance is consumed by agent runs quickly; a parallel 4-agent session can use a day’s budget in an hour.
- The index does not cover files matched by
.gitignoreby default, so agents cannot see your generated types unless you add the folder. - Long conversations degrade. Start a new agent for a new task instead of extending a chat that already has 40 turns.
- It is still a VS Code fork, so JetBrains-only workflows do not port.
Who should upgrade now, and who should wait
Upgrade now if you already rely on chat-driven edits and want fewer hand-offs between files. Wait if your team pins a Cursor version for compliance review — the agent permission model changed, and a half-reviewed policy will not match the new behaviour.
Do not upgrade if you are mainly looking for cheap AI completions. The free tier of the 2.0 line is more restrictive on agent runs than it used to be, and a lighter editor with a borrowed API key will cost less.
Quick Summary
- Cursor 2.0 adds a multi-agent workspace and a retrained Composer model; settings carry over through the in-app updater.
- Keep terminal and delete permissions on ask, commit before every run, and give each agent a single scoped task.
- Pro stays at $20/month, but parallel agents consume the request allowance much faster.
- Composer suits multi-file planning; Apply suits single-function edits.
- Parallel agents only pay off with three or more independent workstreams — otherwise orchestration overhead wins.
