Cursor 3 is the first version of the product that isn't a VS Code skin. The editor has been rebuilt around agents instead of files, and after six weeks of using it as my daily driver the change is bigger than the marketing makes it sound. It is not "an IDE with better AI." It is an agent management surface that happens to contain an editor when you need one.
This article is the practitioner's read on what actually changes day to day, and what doesn't.
The Headline: The Agents Window
The new entrypoint is the Agents Window. Open it with Cmd+Shift+P → Agents Window and what you see is a sidebar of every agent currently running. local edits, parallel runs in git worktrees, cloud agents kicked off from cursor.com/agents, and any sessions started from mobile, Slack, GitHub, or Linear. They all surface in one place.
The shift in mental model is the point. In Cursor 2 I held one chat at a time in my head; the rest of my agents were either invisible or in a tab I had to remember to check. In Cursor 3 the agents are the workspace, and the editor is one of the views you open when you want to drop down to file-level work.
Three concrete consequences:
- I run more agents simultaneously. Three or four at a time is normal now. One refactor, one bugfix, one investigation, one cloud agent on a longer task. The cognitive overhead of remembering what's running is gone.
- Cross-repo work is easier. The window is inherently multi-workspace. A change that spans two repos used to require two windows; it now requires one with two agents.
- The agent feels primary, not bolted on. Subtle, but real. The shift from "I am editing, and AI helps" to "agents are doing the work, and I am steering" lands in the muscle memory after a week.
The Two Commands That Actually Change Workflow
Two slash commands inside the Agents Window are worth pulling out because they change how I structure tasks.
/worktree creates an isolated git worktree for the current agent. Whatever the agent does, it does there. No risk of contaminating my working branch, no git stash rituals, no "let me back out and try a different approach." When I'm happy with a worktree, I bring the changes into my main checkout; when I'm not, I throw the worktree away. The friction of running speculative work has dropped to roughly zero.
/best-of-n is the more interesting one. It runs the same task in parallel across multiple models, each in its own isolated worktree, and lets me compare the outcomes side-by-side. (This is roughly the level-4 parallel-agents pattern from my five levels of Claude framework, made native to the IDE.)
/best-of-n "Extract the billing logic into a separate service.
Preserve the existing public API."
For routine work this is overkill. For a non-trivial refactor it has become my default. The cost of running three agents in parallel for ten minutes is small; the value of picking the one that actually nails it is large. I have stopped trying to predict which model will produce the cleanest output on any given task and just let /best-of-n decide.
Design Mode Closes the UI Feedback Loop
Design Mode is the feature I underestimated. Toggle it with ⌘+Shift+D, and you can annotate UI elements directly in the browser. Shift-drag to select a region, ⌘+L to send it into the chat, ⌥+click to attach it to the current prompt.
The reason this matters is that "fix the padding on the card hover state" is a sentence with three different valid interpretations. With Design Mode I am no longer describing the target in prose. I am pointing at it. The agent gets the DOM context, the screenshot, and the surrounding styles in one shot.
The CSS-and-spacing loop, which used to take three or four turns of "no, the other card" and "no, the inner padding not the outer," now usually resolves in one. That is the most user-visible quality-of-life win in the release for anyone shipping product UI.
Cloud Agents and the Handoff
The other piece I have come to rely on is the local-to-cloud handoff. I can kick off a long-running task in the cloud, walk away from my machine, and pick up the session locally an hour later for testing. Or the reverse: start something locally, push it to the cloud when I close the laptop, let it keep running.
Two things make this load-bearing in practice:
- Cloud agents now show demos and screenshots in their output. I can verify what an agent did at a glance before pulling the work back to local. No more "did the cloud agent actually do the thing it said it did?"
Composer 2(and now Composer 2.5) runs locally; the same session can resume in the cloud. The model context is portable, not the model. If I have a workflow that depends on local file watchers or my dev server, I keep it local. If I want offline persistence, I push it to cloud.
This is the feature that earns Cursor 3 its place in long-horizon work. Pre-3, a 90-minute cloud agent run felt like a separate product. Now it is just another tab in the same window.
Agent Tabs, the LSP, and the Browser
A handful of smaller wins that compound:
- Agent Tabs in the editor let me view multiple chats at once, side-by-side or in a grid. This sounds trivial. It is not. Comparing two agents' approaches without flipping between them changes how I review their work.
- Full LSP support. "Go to definition" works inside agent-edited code the same way it does in code I wrote. Cursor 2's editor occasionally felt half-instrumented; Cursor 3 doesn't.
- Built-in browser. Open a local website inside Cursor, prompt against it, hand the agent a navigation target. Combined with Design Mode, this is where most of my UI work now happens.
- Marketplace. Plugins, MCPs, skills, and subagents installable from a marketplace. Team marketplaces for private extensions. Early days, but the right shape.
What's Not Changed
The honest expectation-setting:
- The model still hallucinates. A prettier interface does not change the underlying probabilistic output. Evals, code review, and tests remain non-negotiable. (Most of the production failure modes I've seen in AI agents still apply regardless of which IDE you ship from.)
- Prompt discipline still matters. A vague task description in Cursor 3 produces a vague result, the same as it did in 2.x. Design Mode and
/best-of-nraise the floor; they do not remove the need for clear intent. - Multi-provider risk hasn't gone away. Cursor's interface is a layer on top of whichever model you pick. Treat model selection the same way you did last year. don't bet the company on a single vendor regardless of how good the harness is.
- You will run more agents and spend more on inference. The interface makes parallel agent runs frictionless, and the bill reflects that. Worth knowing before the first invoice.
The Migration Question
For teams already on Cursor 2.x, the move is a download. No prompt rewriting, no config migration. The decision is whether you adopt the new patterns or keep using it like the old editor with a different paint job.
My recommendation:
- Spend the first week in the Agents Window, not the IDE view. Force the new mental model. The instinct to fall back to file-tree-and-editor is strong; resist it for a week and the agent-first workflow clicks.
- Pick three real tasks and run
/best-of-non them. This is the fastest way to internalise the parallel-agents pattern. - Use Design Mode the next time you touch CSS. It will pay for the upgrade by itself.
- Don't migrate agent loops you've manually tuned in 2.x yet. Validate them in the new harness first; the underlying behaviour is similar but not identical, and a small regression in a high-traffic agent is worth catching early.
The Practitioner's Take
The framing that has stuck with me is that IDEs are turning into agent management consoles. The editor isn't going away. but it is sliding from "the main thing I do" to "the place I drop into when an agent needs me to make a judgement call."
Cursor 3 is the first product to commit fully to that direction rather than treating agents as a side panel. It is also the first to make the parallel-agents pattern feel native instead of bolted on, and the first where the cloud and local sessions are genuinely the same thing.
Whether you stay on Cursor or move to a competitor over the next year, this is the shape of the category now. The IDEs that don't adapt to it will look like Sublime Text did the day VS Code shipped. fine, technically capable, and conceptually a generation behind.