cursor 2

Cursor 2, released on October 29, 2025, doubles down on being the best place to work with AI agents. The Composer frontier model now lives inside the editor, while a redesigned multi-agent canvas, agent-aware testing, and workflow upgrades keep developers shipping code faster than ever.

Composer completes most turns in under 30s—about 4× faster than comparable models.
Up to eight concurrent agents explore solutions in isolated worktrees for conflict-free iteration.
Cursor 2 Motion Preview
Composer Model Latency ≤30s
Avg completion 4× faster
Tokens consumed −4.5× output
Repo coverage Semantic search

Cursor 2 runs in non-thinking mode by default, switching to deep reasoning only when complex refactors demand it.

What's new in Cursor 2

Cursor 2 bundles Composer, multi-agent orchestration, browser debugging, and enterprise controls into a cohesive launch. Dive into the motion previews and guides below to experience every upgrade first-hand.

Cursor 2 launch deck
Agent canvas

Cursor 2 multi-agents workspace

Manage every agent from a dedicated sidebar, orchestrate up to eight parallel runs on one prompt, and keep plans visible without juggling files.

  • Each agent edits an isolated git worktree or remote sandbox, eliminating merge conflicts.
  • Compare candidate diffs side by side, then merge the strongest solution into your cursor 2 codebase.
Composer model

Cursor 2 Composer frontier model

Composer is Cursor’s first in-house agentic coding model, engineered to deliver low-latency turns that keep momentum high across large repositories.

  • Completes most requests in under 30 seconds—roughly 4× faster than similarly capable models.
  • Semantic-search training lets Composer navigate monorepos with better context recall.
Browser (GA)

Cursor 2 browser testing loop

Embed the browser directly in the editor so agents can select DOM elements, forward page context, and iterate on UI fixes without leaving Cursor 2.

  • General availability delivers enterprise-ready browser sessions with richer tooling.
  • Agents can capture screenshots, validate flows, and retry until tests pass.
Review

Cursor 2 improved code review

Inspect every file the agent touched inside one diff viewer, with plans and context pills pinned next to the changes for quicker approvals.

  • Unified multi-file review keeps focus on the agent’s intent and impact.
  • Jump back to the classic IDE layout whenever you need deeper manual edits.
Terminal

Cursor 2 sandboxed terminals

Run agent-issued shell commands safely. Cursor 2 elevates the sandbox to GA, defaulting to secure macOS environments with limited workspace access.

  • Read/write privileges stay scoped to the project, and outbound network calls stay blocked.
  • Enterprise admins can enforce sandbox policies across every developer.
Team commands

Cursor 2 team & shareable commands

Publish curated prompts, rules, and workflows from the Cursor dashboard so every teammate automates with the same playbook.

  • Deep links distribute presets instantly to collaborators.
  • Shareable Team Commands keep governance centralized and editable by admins.
Voice mode

Cursor 2 voice-first workflows

Dictate prompts, set custom trigger phrases, and let the agent execute tasks while you stay in flow or code hands-free.

  • Built-in speech-to-text keeps accuracy high for complex instructions.
  • Voice mode pairs perfectly with Composer for rapid follow-up edits.
Improved prompt UI pills in Cursor 2
Prompt ui

Cursor 2 improved prompt UI

Files, directories, and recent context now surface as inline pills, while the agent auto-gathers definitions, lint errors, and links for you.

  • Cleaner context management supports deep prompts without manual tagging.
  • Copy and paste prompts with embedded context in one click.
Plan mode running in the background with multiple agents
Plan mode

Cursor 2 plan mode in the background

Design plans with one model while another builds them, or let parallel agents draft multiple plans you can review side by side.

  • Choose foreground or background execution to balance speed and oversight.
  • Perfect for ambitious cursor 2 refactors that need several agent perspectives.
Performance

Cursor 2 performance gains

Faster Language Server Protocol startup, dynamic memory scaling for Python and TypeScript, and leak fixes make Cursor 2 feel instantly responsive.

Read performance notes
Agent harness

Cursor 2 agent harness

A revamped harness boosts reliability across every model, with notable quality jumps for GPT-5 Codex inside cursor 2 projects.

Harness improvements
Cloud agents

Cursor 2 cloud agents

Cloud agents now deliver 99.9% reliability, instant startup, and a refreshed UI on the horizon for sending runs beyond your laptop.

Cloud agent roadmap
Enterprise

Cursor 2 enterprise controls

Enforce sandbox policies, distribute hooks from the dashboard, and audit every admin event to keep enterprise cursor 2 environments compliant.

Enterprise upgrades

What is Cursor 2?

Cursor 2 mission overview

Cursor 2 reimagines the VS Code-based editor as an AI-native workspace that elevates agents over individual files. Every workflow orbits the outcome you want—brief an agent, review its plan, and merge the best diff—so the path from idea to shipped commit is dramatically shorter.

Cursor 2 architecture snapshot

Git worktrees or remote sandboxes isolate each agent run, while semantic search feeds Composer rich context across the entire repository. This “agents-first” architecture lets up to eight assistants iterate in parallel without clashing changes or missing long-range dependencies.

Cursor 2 release timing

Launched on October 29, 2025 as a free upgrade, Cursor 2 formalized Cursor’s vision of being the best place to work with agents by bundling Composer, the new agent console, and quality-of-life tooling in one release.

Cursor 2 codebase coverage

Composer handles monorepos and legacy stacks with semantic recall, bridging gaps between services, CI pipelines, and historical diffs for richer reasoning.

Cursor 2 support cadence

Release notes, changelogs, and onboarding guides remain centralized at cursor.com, detailing every improvement from UI toggles back to the classic layout to agent plan management.

Features of Cursor 2

Cursor 2 Composer model

Composer is engineered for low-latency, agentic coding. Most edits, refactors, and reviews land in under 30 seconds—about 4× faster than similarly capable models—and its semantic-search training keeps context intact across sprawling codebases.

  • Adaptive reasoning activates only for complex problems
  • 4× faster on equivalent tasks for iterative coding loops
  • Optimized for incremental diffs across big repositories

Cursor 2 multi-agent interface

Engineers can launch up to eight parallel agents, compare results, and merge the strongest diff. A right-side sidebar tracks plans, outputs, and quick toggles back to the classic IDE view when needed.

  • Git worktrees keep simultaneous runs conflict-free
  • Supports GPT-5, Claude 4.5 Sonnet, and future models
  • Agent status dashboard surfaces progress, context pills, and approvals in real time

Cursor 2 browser tool

A built-in browser environment lets agents run end-to-end tests, capture screenshots, and iterate on interface bugs without leaving the editor, graduating from beta to general availability in Cursor 2.

  • Ideal for debugging CSS, rendering, and network calls
  • Generates visual artifacts to support code reviews
  • Combines with Composer for closed-loop UI fixes

Cursor 2 voice-to-text

Hands-free input transforms spoken instructions into code edits. Voice Mode provides speech-to-text and custom trigger phrases so you can talk to the agent while staying in flow.

  • Tuned for accurate command interpretation
  • Feeds Composer for instant agent execution
  • Supports collaborative walkthroughs and demos

Cursor 2 performance boosts

Memory usage drops dramatically, inference speeds climb, and review tooling delivers sharper diffs for deeper inspection. LSP features now load faster across languages and cloud agents boast 99.9% uptime with instant startup.

  • Auto mode now routes requests through Composer
  • Improved stability across large workspaces
  • Enhanced compare view for complex code changes

Code review & testing in Cursor 2

Cursor 2 streamlined reviews

Reviewing agent work is now frictionless. Cursor 2 aggregates every file change in a unified diff viewer so you can inspect the full impact without hunting through folders. Context pills highlight referenced files, plans sit beside the diff, and switching back to the classic editor view is one click away.

  • Multi-file diffs in a single pane for deeper inspections
  • Agent plans and reasoning logs surface next to code changes
  • Faster approvals for complex refactors and bug fixes

Cursor 2 browser testing loop

The integrated browser tool graduates to general availability in Cursor 2, letting agents execute UI flows, select DOM elements, and keep iterating until the experience matches the prompt. This keeps the model inside a sandboxed environment while closing the loop between writing and validating code.

  • Embedded browser sessions for frontend and end-to-end validation
  • Automatic retries until tests pass or regressions are surfaced
  • Sandboxes isolate browser runs while preserving workspace integrity

Cursor 2 comparison dashboard

Capability Cursor 2 Previous Cursor Claude 4.5 Sonnet
Average task completion Under 30 seconds with Composer 1–2 minutes on complex edits About 1.8 minutes
Token efficiency ≈4.5× fewer tokens per diff Moderate reduction with caching High token footprint
Parallel agents Agent-centric UI + git worktrees Single agent focus Limited concurrency
Browser debugging Native browser tool with screenshots Depends on external tools No integrated browser
Pricing structure Usage-based, Composer priced like GPT-5 Credit-based plans Higher per-token costs
Accessibility features Voice-to-text with agent execution Manual integrations required No first-party tools

How to use Cursor 2

Step 01

Install Cursor 2 package

Download the update from cursor.com/download and migrate your editor.

Step 02

Enable Cursor 2 Composer

Set Composer as the default Auto mode model so everyday prompts enjoy low latency and richer context.

Step 03

Configure Cursor 2 multi-agents

Launch parallel agents for tricky features. Git worktrees keep experiments isolated and conflicts in check.

Step 04

Use Cursor 2 browser tool

Run UI tests, capture screenshots, and validate front-end fixes without swapping applications.

Step 05

Adopt Cursor 2 voice input

Convert spoken prompts into code changes, ideal for walkthroughs or when resting your hands.

Step 06

Monitor Cursor 2 metrics

Track completion time and token usage to optimize budgets and developer satisfaction.

Step 07

Gather Cursor 2 feedback

Sync with your team on agent outputs, then publish shared prompts or Team Commands so every developer benefits from the strongest workflow.

Step 08

Stay current with Cursor 2

Review changelog updates to capture new multi-agent tricks, sandbox improvements, and performance optimizations as they land.

Cursor 2 user feedback pulse

Pro teams on Cursor 2

Large teams praise Composer’s speed, crediting it with resolving long-standing bugs within minutes of parallel agent experimentation.

Power users on Cursor 2

Some users note the agent-centric UI feels unfamiliar and warn that running multiple agents can increase token usage without guardrails.

Community on Cursor 2

Threads on Reddit highlight excitement for problem-solving speed while flagging issues like broken hot reloading in certain setups.

Additional tools in Cursor 2

Cursor 2 sandboxed terminals

Agent-issued shell commands now run in secure sandboxes by default on macOS, inheriting the beta feature from v1.7 and granting read/write access only to your workspace while blocking unapproved network calls.

  • Protects your machine when agents automate scripts
  • Worktree-scoped permissions keep edits contained
  • Prevents hidden downloads or outbound traffic by default

Cursor 2 team workflows

Team Commands let leaders ship curated prompts or rules across the organization through shareable deep links. Every teammate inherits the same presets inside Cursor 2 for consistent, policy-aligned automation.

  • Shared commands live in the Cursor dashboard
  • Deep links sync presets instantly across teammates
  • Ensures AI-generated code follows team conventions

Cursor 2 context upgrades

Prompt UI enhancements surface referenced files as inline pills, and Composer can auto-gather definitions, recent changes, or lint errors. Combined with Voice Mode’s trigger phrases, developers juggle context hands-free.

  • Voice Mode pairs speech-to-text with custom triggers
  • Context pills keep alignment visible in every chat
  • LSP and cloud-agent performance boosts enhance responsiveness

Cursor 2 pricing and plans

Cursor 2 individual access

Existing users receive Cursor 2 as a free update, keeping solo developers on the latest Composer model without extra charges.

Cursor 2 team billing

Team plans move from credit-based to usage-based billing, aligning costs with real Composer consumption and repository size.

Cursor 2 cost efficiency

Although Composer costs match GPT-5 per token, efficiency gains mean equivalent tasks average 73% cheaper thanks to shorter responses.

Cursor 2 FAQ

How does Cursor 2 Composer reduce completion times?

Composer is tuned for low-latency prompts, completing most tasks in under 30 seconds by defaulting to non-thinking mode until deeper reasoning is required.

What makes Cursor 2 multi-agent workflows unique?

Cursor 2 lets you run agents in parallel and compare their diffs side by side, all while git worktrees keep branches isolated.

Can Cursor 2 handle very large repositories?

Yes. Semantic search and contextual retrieval allow Cursor 2 to navigate monorepos and legacy codebases without losing track of dependencies.

Does Cursor 2 support browser-based debugging?

A native browser tool lets agents run client-side tests, capture screenshots, and debug UI issues directly in the editor.

How does Cursor 2 pricing compare with GPT-5 usage?

Composer is priced like GPT-5 per token, but overall workflows cost less because Cursor 2 produces shorter, more targeted outputs.

Is Cursor 2 voice input secure for confidential code?

Yes. Voice prompts travel through the same encrypted channels as text, keeping enterprise security intact.

Can Cursor 2 revert to the classic interface layout?

A layout toggle returns the sidebar to its previous position so teams can transition gradually while testing multi-agent workflows.

What integrations does Cursor 2 offer for testing?

Agents can trigger browser UI checks, run automated tests, and surface diffs, helping teams validate changes before merging.

How can Cursor 2 leverage third-party AI models?

The multi-agent hub accepts GPT-5, Claude 4.5 Sonnet, and future models, enabling head-to-head comparisons on the same task.

Where can I read the full Cursor 2 changelog?

Visit cursor.com/changelog/2-0 for every enhancement, bug fix, and performance note tied to Cursor 2.

Launch your Cursor 2 workflow

Cursor 2 starter checklist

  • Download the latest Cursor 2 installer package
  • Enable Composer for Auto mode and diff review
  • Activate browser and voice agents for full coverage