The first thing you notice in Cursor 2.0 isn't the new model. It's that the editor stopped putting files in the center. Open the redesigned interface and the primary object on screen is an agent — a running task with its own working copy, its own diff, its own review queue — and your source tree is now something you drop into when you want to inspect what an agent did. That reframing is the actual story of this release, more than any benchmark number, and it changes how you're expected to work.
Cursor shipped 2.0 on October 29, 2025, bundling two things that get announced together but solve different problems: Composer, the company's first in-house coding model, and a rebuilt UI designed to run several agents at once. Let me take them in that order, because the model is the easier one to evaluate.
Composer: speed as a design goal, not a bragging right
Composer is described as an agentic coding model that is "4x faster than similarly intelligent models," completing most turns in under 30 seconds. The concrete figure underneath that claim: it sustains generation around 250 tokens per second. Architecturally it's a Mixture-of-Experts model, trained with reinforcement learning inside sandboxed coding environments where it had access to real tools — file editors, terminal, semantic codebase search — and was rewarded for solving tasks correctly and efficiently. Cursor reports its standing on an internal benchmark it calls Cursor Bench, where the pitch is near-frontier intelligence at by far the best speed.
Here's why the speed number matters more than it looks. An agent loop is generate → run → read the result → correct. When each turn takes two minutes, you context-switch away and the loop breaks; you stop supervising and start batch-reviewing at the end, which is where bad agent output quietly accumulates. Pull the turn under 30 seconds and you stay in the loop — you watch it test, fail, and fix without leaving the tab. Composer is optimized for the thing that keeps a human in the review seat, not for topping a leaderboard. It's a reasonable trade, and Cursor is explicit that it made it.
The same release also folds in an improved agent harness that Cursor says lifts quality for external models like GPT-5 Codex, so Composer isn't the only thing that got faster or better — the scaffolding around every model did.
The real shift: agents over files, and running eight of them
The interface is "designed from the ground up to be centered around agents rather than files." The headline capability: run up to eight agents in parallel on a single prompt, each isolated so they don't clobber each other. Isolation comes from git worktrees or remote machines — each agent gets its own checkout, so two agents editing the same file never collide.
This leans on a git feature that predates any of this and is worth knowing directly, because it's the primitive the whole feature rests on:
# One repo, several working directories, each on its own branch.
git worktree add ../attempt-a -b agent/attempt-a
git worktree add ../attempt-b -b agent/attempt-b
git worktree list
# /repo 9f2c1a4 [main]
# /repo/attempt-a 9f2c1a4 [agent/attempt-a]
# /repo/attempt-b 9f2c1a4 [agent/attempt-b]
Cursor is automating exactly this: fan the same task out to parallel agents, let each build in its own tree, then compare results. The rationale it gives is blunt and, in my experience, correct:
Having multiple models attempt the same problem and picking the best result significantly improves the final output, especially for harder tasks.
That's not a novel idea — it's best-of-N sampling — but wiring it into the editor with real isolation makes it usable on production code instead of a toy. You describe a gnarly refactor, three agents take a swing at it in parallel, and you merge the one that's actually right. Planning is part of this too: you can draft a plan with one model and execute it with another, in the foreground or in the background, or run parallel planning agents to get several plans to choose from.
The supporting cast graduated from beta
A few things that were experimental are now generally available and matter for day-to-day use:
- In-editor browser. The native browser tool went GA. It embeds in the editor and can select DOM elements and forward that information to the agent, so a UI-fixing agent can see the rendered page it's changing instead of guessing from source.
- Sandboxed terminals (macOS). Shell commands that aren't already allowlisted run automatically in a sandbox with read/write access to your workspace and no internet access. That's a sane default for letting an agent run commands without handing it your whole machine.
- Voice control. You can drive the agent with speech-to-text and set a custom submit keyword to fire off execution.
There's housekeeping worth flagging so you're not surprised: Notepads are deprecated, and Background Agents were renamed Cloud Agents. Team and enterprise admins also get centrally managed rules and commands (applied without local files), audit logging of admin events, and cloud distribution of hooks.
What actually changed
The model got faster; that's real and it's nice. But the durable change is that Cursor is betting the bottleneck in AI-assisted development has moved. Generation is cheap now — you can spawn eight attempts before your coffee's poured. What's expensive is deciding which output to trust, and 2.0 is built around that assumption: parallel attempts, fast review of multi-file diffs, agents that gather their own context, a browser so the agent can check its own work.
So the concrete takeaway isn't "switch to Composer." It's to restructure how you hand off work. Stop feeding one agent one prompt and babysitting it. Give the same hard problem to several agents in isolated worktrees, then spend your attention where it now pays — comparing and rejecting. The editor moved the center of gravity from files to agents. If your workflow stays file-by-file, you're using a 2.0 tool with a 1.0 process.
Sources: New Coding Model and Agent Interface · Cursor changelog 2.0, Introducing Cursor 2.0 and Composer · Cursor, Composer: Building a fast frontier model with RL · Cursor