Cursor 3 “Glass” Review — The Agent-First Interface, Tested

What Actually Changed in Cursor 3

Cursor has been through two major identity shifts. Version 1 was a VS Code fork with smart autocomplete. Version 2 added a conversational chat panel that could touch files. Cursor 3 tears out the chat panel and rebuilds the interface around a concept they call the Agents Window — a persistent orchestration layer where you dispatch agents to tasks rather than type requests into a chat box.

The difference is subtle in description but obvious in practice. In Cursor 2, you wrote a prompt, the AI responded and made edits, and you iterated conversationally. In Cursor 3, you create a task, assign it to an agent, monitor its progress in a dedicated pane, and review the result when it surfaces. The mental model is closer to a project manager reviewing work than a programmer pair-programming with an AI.

Three other structural changes shipped alongside the interface rebuild: multi-repo layout (you can open several repositories in a single workspace and agents can read and write across all of them), cloud agent execution (tasks run on Cursor's infrastructure, not your local machine), and Design Mode (a visual editor for UI components). Each is significant enough to cover separately.

Cursor also announced that it crossed $2B ARR at launch — roughly double what it reported three months earlier. With approximately 25% of the AI coding tool market, it has moved from a promising VS Code fork into the category of infrastructure that teams depend on daily. That scale changes what a version bump means: Cursor 3 is an architectural bet, not a feature drop.

The Agents Window Explained

The Agents Window sits in the left sidebar, roughly where the file explorer used to dominate. It shows active agents as cards — each with a task description, current status (Planning / Executing / Reviewing / Done), the files it has touched, and a diff preview. You can pause, restart, or fork an agent from here without interrupting others.

What this changes, concretely: you can assign five tasks at once and let them run while you work on something else. In Cursor 2, every agent interaction blocked the chat panel. In Cursor 3, it's closer to running five terminal processes in tmux — you switch between them when you need to, not when the AI demands a response.

There is a learning curve. The old workflow of “chat with AI, accept changes, chat more” is gone. New users spend a couple of sessions figuring out how granular to make task descriptions, whether to assign context files upfront or let the agent discover them, and how to handle agents that go in the wrong direction before they complete.

Task Scoping: Where Most Users Get It Wrong

In our testing, the biggest friction point was task scope. Tasks that are too broad (“refactor the auth module”) produce agents that make sweeping changes requiring extensive review. Tasks that are too narrow (“rename this variable”) feel like overkill — you'd just do it yourself faster. The sweet spot is medium-sized discrete tasks: “add rate limiting to the /api/auth/login route, using the existing middleware pattern in /api/users”.

Cursor's documentation acknowledges this by providing a task template library — roughly 40 pre-structured task formats organized by category (bug fix, feature addition, refactor, test generation, documentation). They're genuinely useful for getting the scoping right, especially the first few days.

Cloud Agents and Parallel Execution

Cloud agents are the feature with the widest gap between the demo and daily use. In the launch video, Cursor shows six agents working in parallel across different repositories, completing tasks in minutes while the developer reviews a pull request. That's real — the infrastructure works. The constraint is compute allocation.

Pro plan ($20/month) includes a monthly cloud compute budget that, in practice, runs out after roughly 15-20 complex parallel sessions. After that, agents fall back to running locally on your machine. Business plan ($40/month per seat) has a higher allocation, and Cursor has indicated enterprise tiers with uncapped compute are coming. For now, Pro users who lean heavily on parallel execution will hit the ceiling.

Multi-repo layout solves a genuine pain point. Before Cursor 3, working across a frontend repo and a backend API repo meant constant context-switching — copying types, pasting examples, maintaining mental context between two editors. With multi-repo, you add both repos to a single workspace, and agents can read across them. When an agent modifies a shared type in the backend, it can simultaneously update the frontend usage without you having to orchestrate that manually.

How Cloud Agents Compare to Local Execution

Cloud agents are meaningfully faster on long-running tasks — we saw roughly 3x speed improvement on a 500-file refactor compared to running locally on an M3 MacBook Pro. The trade-off is that cloud agents require uploading your codebase to Cursor's servers. Cursor encrypts code in transit and at rest and offers a Business Associate Agreement for enterprise customers, but teams with strict data residency requirements should read the privacy documentation carefully before enabling the feature.

Design Mode: Visual UI Editing

Design Mode is activated with a toolbar button and opens a split view: your code on one side, a live browser preview on the other. You click on any element in the preview — a button, a card, a nav item — and a contextual panel appears with natural language instructions. You type what you want changed (“make this button red, increase padding to 16px, add a loading spinner on click”) and an agent modifies the source code, with the preview updating in real time.

It works well for isolated component changes. We used it to restyle a dashboard card grid, adjust spacing across a settings form, and add hover states to a navigation menu. In each case, the agent correctly identified the relevant component file, made targeted changes, and previewed them without touching unrelated code. Time savings compared to doing it manually: somewhere between 20 and 40%, which compounds over a full day of frontend work.

The limitations are real, though. Design Mode struggles when the element you click has styling inherited from multiple sources — a Tailwind utility class, a CSS module, and a parent component's className, for instance. The agent sometimes modifies the wrong layer, fixing the visual but creating specificity conflicts. Complex interactive states (hover, focus, active, disabled all needing coordination) also require careful prompting to get right in a single pass.

It is not a Figma replacement and does not try to be one. The closest analogy is a browser DevTools inspector that writes code instead of just describing what it sees. Designers will still need to hand off specs; Design Mode closes the last mile between those specs and production code.

Cursor 3 vs Claude Code vs OpenAI Codex

The competitive landscape shifted the same week Cursor 3 launched. Google Antigravity (their internal coding agent, leaked to media) is apparently in private beta. OpenAI Codex updated its web interface. Claude Code received a silent update to its subagent orchestration. Cursor 3 is competing in a market that is moving weekly, not quarterly.

The category comparison is the more interesting one. Cursor is making a deliberate push to be classified as “workflow automation” rather than “code editor.” The Agents Window, parallel execution, and cloud compute all push in that direction. Claude Code, by contrast, remains committed to terminal-first depth — it goes further autonomously on complex tasks but gives you less visual orchestration.

For teams that want to see what their agents are doing through a GUI, Cursor 3 has no real competition right now. For teams that want the deepest autonomous execution on long, complex tasks, Claude Code still leads in our head-to-head testing. These are genuinely different tools serving different working styles, and the overlap is smaller than either camp usually admits.

What Developers Are Actually Saying

Reactions in the first week were split roughly 60/40 positive. The 60% are developers who had started hitting the ceiling on Cursor 2 — the chat panel felt limiting for larger tasks — and find the Agents Window genuinely freeing. The 40% are users who liked the directness of the old chat interface and are frustrated by having to re-learn the mental model.

What People Like

• ✓ Parallel execution is a real productivity gain — several developers on X reported finishing full-day tasks in a few hours by running 3-4 agents simultaneously
• ✓ Multi-repo context cuts a persistent annoyance — frontend/backend teams in particular mention this as the single most useful change
• ✓ Design Mode is useful enough to change how some people work — a handful of solo developers say it has replaced their Figma-to-code workflow for small projects
• ✓ Task templates help new users — the 40+ task formats reduce the scoping problem significantly for developers still finding their feet with agent workflows

The Honest Complaints

• ✕ Cloud compute limits on Pro are too low. Several developers building full-time on Cursor say they exhaust the monthly allocation mid-month and spend the rest of the month on slower local execution.
• ✕ The learning curve is steeper than Cursor 2. The old chat interface was approachable in minutes. The Agents Window takes a few days to use well.
• ✕ Design Mode has a specificity problem. When component styling comes from multiple sources, agents sometimes modify the wrong layer, creating CSS conflicts that are annoying to debug.
• ✕ Agent recovery is clunky. When an agent goes off-track, the correction workflow — pause, describe the wrong turn, redirect — is more friction than just continuing a conversation was in Cursor 2.
• ✕ Data residency questions remain open. Cloud agents require codebase upload. Cursor's privacy controls are reasonable but some enterprise teams are waiting on clearer data residency guarantees before enabling the feature.

A common thread in more critical reviews: Cursor 3 is optimized for a specific kind of developer — someone comfortable thinking in task queues and agent workflows, working on codebases large enough that parallelism matters. For a developer building a personal project or doing quick edits, some of the new complexity adds friction without proportional benefit.

Is Cursor 3 Worth the Upgrade?

For existing Cursor Pro users: yes, with caveats. The interface rebuild is not optional — there is no Cursor 2 mode. If your team has built workflows around the old chat interface, budget a few days for adjustment. The parallel agent execution and multi-repo layout are worth that adjustment cost for most teams working on codebases above a certain size. Roughly, if you regularly work across more than one repository or spend more than 20% of your day on agent-assisted tasks, Cursor 3 will pay off within a week.

For developers evaluating Cursor for the first time: Cursor 3 makes the tool harder to evaluate on a trial basis. The productivity gains from parallel agents require a workflow shift that takes a few days to internalize — which means a 7-day free trial undersells the tool if you spend most of it adapting. If you have the option, request a 14-day evaluation.

For teams choosing between Cursor 3 and Claude Code: read the comparison section above carefully. They're genuinely different tools now. Cursor 3's GUI orchestration and Design Mode are unique; Claude Code's terminal autonomy and MCP integration are. Windsurf sits in a different part of the market — lighter, faster to evaluate, but lacks the depth of either Cursor 3 or Claude Code for complex tasks. Teams investing seriously in agent workflows are increasingly running Cursor 3 for day-to-day work and Claude Code for autonomous overnight tasks.

The $2B ARR number matters as a signal. Cursor is not a startup that might pivot away from coding tools next year. It is infrastructure. Whether Cursor 3's agent-first architecture becomes the category standard or gets superseded by something else in twelve months is an open question — but right now, it is the most complete GUI-based agent orchestration environment available.

FAQ