Cursor 2.0: New AI Model Explained

Cursor 2.0 represents a major update to the AI coding platform. The release centers on Composer, Cursor‘s first proprietary coding model, and a redesigned interface built around agent workflows. You can now run up to eight AI agents simultaneously, with performance improvements that speed up everyday coding tasks.

Composer: Cursor’s first coding model

Cursor 2.0 introduces Composer, a mixture-of-experts model trained through reinforcement learning. The training process placed the model inside real codebases where it learned to use actual development tools like semantic search, file editors, and terminal commands. This hands-on training allowed Composer to pick up practical behaviors such as running tests, fixing linter errors, and navigating large projects.

The performance numbers stand out as most tasks are completed in under 30 seconds at around 250 tokens per second. That makes Cursor 2.0 Composer roughly 4x faster than models with comparable intelligence.

Model positioning and comparisons

Composer lands in the mid-frontier category. It matches models like Claude Haiku 4.5 and Gemini Flash 2.5 in capability, but falls short of GPT-5 and Claude Sonnet 4.5 when handling complex architectural problems.

The choice between models depends on the task. Composer works well for quick iterations, routine edits, and incremental changes. For deep architectural decisions or tackling novel problems, the more powerful models deliver better results. Cursor lets developers switch between models as needed.

Cost-wise, Composer offers competitive pricing. The speed advantage reduces token usage per task, and Cursor’s control over the infrastructure keeps costs optimized across the platform.

The parallel agent system extends Composer’s capabilities by running multiple models simultaneously.

Running multiple agents in parallel with Cursor 2.0

Cursor 2.0 lets developers run up to eight agents at once. Each agent works independently, either tackling the same problem from different angles or handling separate tasks simultaneously.

The isolation mechanism relies on Git worktrees or remote machines. Git worktrees create separate workspace copies while sharing the same repository, so each agent modifies files in its own space without triggering conflicts. Changes stay isolated until deliberately merged into the main codebase.

Comparing outputs across models

Running the same task through multiple models produces different approaches. GPT-5 might prioritize error handling, Claude Sonnet 4.5 could focus on clean code structure, and Composer may aim for minimal, fast changes. After agents finish, developers review all outputs side by side and pick the strongest solution. This model comparison helps developers understand how each model performs on different coding tasks.

The apply system gives granular control. Changes can be accepted partially or completely by any agent. The undo function works per agent, so reverting one agent’s work leaves other results intact. Cursor maintains a history of agent runs, making it possible to revisit and reapply previously rejected changes.

This multi-agent approach connects directly to Cursor 2.0’s interface redesign.

Cursor 2.0’s agent-first interface redesign

Cursor 2.0 replaces the traditional file-based layout with an agent-centered design. The new interface organizes work around agents and their tasks rather than individual files.

Agent view vs classic editor mode

Two interface modes accommodate different workflows. Agent view places a sidebar on the right side where developers create, name, and manage multiple agents. Each agent appears as a distinct item with its own status, progress indicators, and output logs. The sidebar shows which agents are running, completed, or waiting, making it easy to track parallel operations.

Classic Editor mode returns the sidebar to its traditional left position with the familiar file tree layout. Developers can toggle between these modes using the “Agents” button in the top-left corner. The quick switch lets teams gradually adopt agent workflows while maintaining access to traditional file navigation when needed.

What the new interface manages

The agent sidebar handles several functions beyond just listing agents. Developers can inspect agent plans, which are multi-step strategies an agent intends to follow. The interface shows context pills indicating which files and code sections each agent is working with. Real-time progress updates display current actions like “searching codebase” or “editing files.”

The redesign removes some traditional elements. File trees no longer dominate the primary view in Agent mode. Instead, files appear inline as pills within conversations or when agents reference them. This shift reflects a workflow where developers specify outcomes and review results rather than manually navigating file structures.

Performance optimizations throughout the platform support this new interface design.

Performance and speed improvements in Cursor 2.0

Cursor 2.0 brings performance upgrades across language support, memory management, and agent capabilities.

Language Server Protocols now load faster and respond quicker across all supported languages. Python and TypeScript receive specific attention with dynamic memory configuration that adjusts based on available system RAM, keeping large projects running smoothly.

Memory leak fixes reduce consumption during extended sessions. The agent harness, which manages how agents interact with code, now handles context selection more efficiently. All models benefit from these improvements, with GPT-5 Codex showing particularly notable quality gains. Agents can read full files when needed without size constraints, and codebase search returns more relevant results.

These upgrades make agent workflows faster and more resource-efficient. Developers can run more agents simultaneously, iterate quickly on changes, and work with larger codebases without performance drops.

Additional features round out the Cursor 2.0 release.

New features in Cursor 2.0

Cursor 2.0 adds several capabilities that expand how agents interact with code and how developers control them.

Browser integration

Cursor 2.0’s browser tool lets agents test web applications directly within Cursor. Agents can launch a browser instance, interact with the application, capture screenshots, and identify issues. The browser runs embedded in the editor with DOM inspection tools, allowing agents to select specific elements and gather page context.

When an agent makes frontend changes, it can immediately test those changes in the browser, spot rendering problems or functional errors, and iterate on fixes without manual intervention. This testing capability moved from beta to general availability in version 2.0.

Voice control

Voice mode adds speech-to-text for controlling agents. Developers can speak instructions instead of typing them. Custom trigger keywords can be configured in settings to start agent execution, making hands-free coding possible during certain workflows. This helps reduce context-switching and allows hands-free coding.

Background planning mode

Cursor 2.0 separates planning from execution. Developers can assign one model to create a plan and a different model to build it. Planning can happen in the background while other work continues, or multiple agents can generate competing plans for review.

This separation allows using faster models for straightforward implementation while reserving powerful models for strategic planning decisions.

Code review improvements

The code review interface aggregates changes across multiple files into a single view. Instead of jumping between individual files to see what an agent modified, developers see all diffs together with clear indicators of which files changed and how.

Enterprise and team features received updates alongside these individual improvements.

Cursor 2.0 team and enterprise updates

Cursor 2.0 introduces centralized management features for teams and additional security controls for enterprise deployments.

Team commands

Team administrators can define custom commands, rules, and prompts from the Cursor dashboard. Once created, these automatically distribute to all team members without requiring local file storage. The system uses deeplinks for instant distribution, ensuring everyone works with the same set of commands and guidelines.

This centralization keeps coding standards and common workflows consistent across the team. Admins can update commands in one place rather than coordinating file updates across individual machines.

Sandboxed terminals

Sandboxed terminal execution reached general availability for macOS in version 2.0. When agents run shell commands, Cursor executes them in a secure sandbox by default. The sandbox provides read/write access to the workspace but blocks internet access, preventing potentially risky commands from affecting the broader system. )

Enterprise administrators can enforce sandbox policies across all developers, ensuring consistent security practices regardless of individual preferences.

Audit logs and hooks

The distribution system tracks command usage and agent activity through audit logs. Enterprise deployments can monitor which commands run, which agents execute, and what changes agents make across the organization. Hooks allow integrating Cursor activity with existing monitoring and compliance systems.

These enterprise features make Cursor 2.0 viable for larger organizations with security and compliance requirements.

Cursor 2.0 represents a fundamental shift in how AI coding assistants operate.

Conclusion

Cursor 2.0 represents a shift toward agent-driven development workflows. Key updates include:

• Composer model completes tasks in under 30 seconds with 4x faster performance
• Support for running up to eight agents simultaneously with Git worktree isolation
• Agent-first interface redesign with option to switch back to classic file view
• Performance improvements across language support, memory usage, and agent capabilities
• New features, including browser integration, voice control, and automatic context gathering

These changes position Cursor 2.0 as a platform built around autonomous agents rather than traditional coding assistance. You can start exploring Cursor 2.0 today — Codecademy’s Intro to AI Coding with Cursor walks you through the setup and first project.

Frequently asked questions

1. Is Cursor AI better than ChatGPT?

They serve different purposes. Cursor excels at integrated coding directly in your development environment with contextual suggestions and codebase understanding. ChatGPT is better suited for general-purpose tasks like explaining concepts, brainstorming ideas, and creating documentation. Choose Cursor for active development work and ChatGPT for learning or planning.

2. Can Cursor write code?

Absolutely. Cursor can generate complete functions, create code from plain English descriptions, refactor existing code, and make multi-line edits across your files. It’s designed specifically for code creation and modification.

3. Is Cursor AI free or paid?

Both options exist. The free tier includes limited features and a one-week Pro trial. Paid plans start at $20/month for Pro, $60/month for Pro+, and $200/month for Ultra which offers significantly more usage credits.

4. Can I code Python in Cursor?

Yes, Python is fully supported and is actually one of the languages where Cursor performs best. It also works well with JavaScript, TypeScript, Java, C++, and most other popular programming languages.

5. Will Cursor upload my code?

Code is sent to servers to power the AI features by default. However, you can enable Privacy Mode in settings to prevent your code from being stored or used for training. You also have the option to disable automatic codebase indexing.

6. Is Cursor just VS Code?

Cursor is built as a modified version of VS Code with AI capabilities integrated directly into the editor. It maintains the familiar VS Code interface but adds powerful features like AI chat, code generation, agent mode, and intelligent autocomplete.