Cursor 2.0 In-Depth Review: Five Major New Features Including Custom Model, Multi-Agent Parallelism, and More

Star product in the code editor space, Cursor, has released version 2.0, bringing heavyweight updates including its custom model Composer, Git Worktrees multi-agent parallelism, a built-in browser, and more. As an AI programming tool that started as a VS Code fork and has reached a $9.9 billion valuation, how do these new features in Cursor 2.0 actually perform? Let's break them down one by one.

From VS Code Fork to Multi-Billion Dollar Valuation: What Makes Cursor Special?

Cursor's rise is nothing short of legendary in the AI programming tools space. At its core, it's a fork of Microsoft VS Code—the code editor Microsoft open-sourced under the MIT license in 2015, whose open extension ecosystem and LSP (Language Server Protocol) architecture made it one of the world's most popular development tools. "Forking" means independently developing a new product while retaining the original codebase. Cursor leveraged VS Code's open-source nature, inheriting its mature editor infrastructure (syntax highlighting, debugger, extension marketplace compatibility), thereby concentrating all R&D resources on deep AI integration rather than building editor fundamentals from scratch. This "standing on the shoulders of giants" strategy was key to Cursor's ability to iterate rapidly and penetrate the market.

In just a few months, the company's valuation skyrocketed from zero to $9.9 billion. The core logic behind this lies in precisely targeting a "sweet spot": programmers who know how to code but simultaneously hate writing code.

Most people still use Cursor in a "friendly assistant" mode: generating some boilerplate code, doing some Tab completions. But Cursor 2.0's ambitions go far beyond that—it wants you to drive multiple AI coding agents working in parallel, simultaneously pushing forward, reviewing, and fixing code on the same project.

Custom Model Composer: The Speed vs. Quality Tradeoff

The most eye-catching change in Cursor 2.0 is the launch of its custom model Composer. The company claims this model approaches the intelligence level of the best frontier models while achieving significant speed improvements. This is crucial because waiting for slow responses from GPT-5 and Claude has been one of the main bottlenecks in AI programming.

However, these claims warrant a healthy dose of skepticism. Composer's benchmarks are internal and closed-source—there's no direct comparison with Claude, GPT-5, or Gemini, and it hasn't appeared on external authoritative benchmarks like LM Arena or SWE-Bench.

These two platforms represent the most credible independent evaluation systems for AI capabilities today: SWE-Bench, proposed by a Princeton University team, contains 2,294 issue-fixing tasks from real GitHub repositories, requiring models to locate problems in real codebases and generate patches that pass unit tests; LM Arena (formerly Chatbot Arena), maintained by UC Berkeley's LMSYS team, uses an Elo rating system to measure overall model capabilities through large-scale blind-test comparisons voted on by real users. Their shared characteristics are independence and reproducibility—anyone can submit models for evaluation, and results are publicly transparent. Composer's absence from these platforms means its performance claims currently lack external cross-validation. "Trust Me Bro"-style self-evaluation has limited persuasive power.

Real-World Testing: Claude vs GPT-5 vs Composer Three-Model Comparison

In actual UI generation tests, Claude, GPT-5, and Composer were used in parallel to build a Neo-Brutalism style button component. Neo-Brutalism is a visual style that has emerged in web design in recent years, characterized by high-contrast solid color blocks, thick black borders, strong shadow offsets, and a deliberately "rough" handcrafted feel—a rebellion against overly refined flat design. This style serves as a high-intensity stress test for AI code generation because it requires models to understand "deliberately unconventional" aesthetic logic. Test results:

• Speed ranking: Composer far ahead > Claude in the middle > GPT-5 noticeably behind
• Quality ranking: Claude and GPT-5's visual results slightly better than Composer

In the second round testing Apple Liquid Glass style buttons, the differences became even more pronounced. Liquid Glass is Apple's brand-new design language announced at WWDC 2025, centered on dynamic refraction, translucent glass textures, and fluid animations, widely applied across iOS 26 and macOS Tahoe system interfaces. Its complex CSS animations and visual effects implementation places extremely high demands on model coding capabilities. In testing, Claude invested the most "effort," generating beautiful animation effects; GPT-5's performance was embarrassingly poor; while Composer surprisingly delivered a respectable result.

Overall, the Composer model shows promising potential, especially with its speed advantage, offering practical value for rapid iteration scenarios.

Git Worktrees Integration: The Core Capability for Multi-Agent Parallel Development

The most "insane" feature in Cursor 2.0 is Git Worktrees integration. Git Worktree is a native feature introduced in Git 2.5 (2015) that allows developers to check out multiple working directories from the same Git repository simultaneously, with each directory in a different branch state while sharing the same .git object database, avoiding the disk space waste of repeatedly cloning repositories. In traditional development scenarios, Worktrees are commonly used for "fixing an urgent bug without interrupting current feature development."

In the AI agent scenario, its value is amplified exponentially: each AI Agent can freely modify files and run tests in an independent Worktree, completely isolated from each other, without file lock conflicts or state pollution. This makes truly parallel "multi-Agent competition" possible, rather than serial queuing.

Imagine this workflow: you're building a design system for a web application and can simultaneously launch three agents using Claude, GPT-5, and Composer respectively, each implementing the same component in an independent Worktree, then you pick the best solution. This "horse race mechanism" dramatically improves development efficiency and output quality.

Agent View and Built-in Browser: Multiplying Frontend Development Efficiency

New Agent View Mode

Cursor 2.0 introduces a new Agent View interface mode, with UI layout specifically optimized for conversation-driven development. When your development workflow centers on AI chat, this view significantly reduces interface clutter, letting you focus more on interacting with the AI.

Built-in Browser: Precisely Pinpointing UI Issues

For frontend developers, the native built-in browser may be the most practically productive update. In previous workflows, when AI produced "rough" code on complex UI features, you needed to view the results in an external browser, locate problematic elements, and then manually describe them to the AI.

Now, the built-in browser allows you to preview pages directly within Cursor, precisely select problematic HTML elements, and add them to the chat context with one click. More importantly, it provides full Chrome DevTools support—Chrome DevTools is Google Chrome's built-in developer tools suite, with its underlying Chrome DevTools Protocol (CDP) enabling third-party tools to programmatically control browser behavior and read its internal state. Cursor's built-in browser integrates CDP to serialize DevTools data (DOM structure, console errors, network responses) and inject them directly into the AI conversation context. The core value of this design lies in eliminating "information translation loss"—developers no longer need to describe complex DOM structures or stack traces in natural language; the AI can directly "see" the raw structured data, dramatically shortening the "discover problem → describe problem → fix problem" feedback loop.

A Sober Look at Cursor 2.0: Is It Worth Upgrading?

Despite the exciting updates in Cursor 2.0, we should remain rational:

1. The custom model's capabilities remain unproven: Composer lacks third-party independent verification, and internal benchmarks have limited credibility. In real-world testing, its speed advantage is clear, but quality still hasn't surpassed mature models like Claude.

2. Business model sustainability: Current mainstream AI programming tools universally face a structural dilemma—their core competitiveness is highly dependent on foundation model providers like OpenAI, Anthropic, and Google, essentially serving as "distribution channels for model capabilities." Once providers adjust API pricing or launch competing products, the moat faces serious challenges. Cursor's custom Composer is precisely an attempt to extend beyond the "product experience layer" into the "model capability layer" to build deeper technical barriers. However, training and maintaining frontier code models requires massive compute investment, and whether it can truly compete with companies like OpenAI and Anthropic at the model level remains unknown.

3. Cost considerations: As jokingly noted, "the only limit to your potential isn't imagination, but how much money is in your bank account." While multi-agent parallel work is efficient, API call costs also multiply.

Overall, Cursor 2.0 represents an important step in AI programming tools evolving from "assisted completion" to "agent collaboration." The Git Worktrees multi-agent parallelism and built-in browser features genuinely address developer pain points. While the custom model Composer still needs more validation, it at least demonstrates Cursor's strategic determination not to remain merely a "UI wrapper layer."

Key Takeaways

• Cursor 2.0 launches its custom model Composer, far faster than GPT-5 and Claude, but with a quality gap remaining and lacking third-party independent benchmark verification from SWE-Bench, LM Arena, etc.
• Git Worktrees integration leverages Git's native multi-working-directory mechanism to enable fully isolated parallel development by multiple AI agents, allowing simultaneous task completion with different models and cherry-picking the best results
• The native built-in browser integrates full DevTools via Chrome DevTools Protocol, enabling precise identification of UI problem elements and direct injection of structured debugging data into AI conversation context
• New Agent View interface mode optimizes UI layout for AI conversation-driven development workflows
• Cursor started as a VS Code open-source fork, has reached a $9.9 billion valuation, and is strategically transitioning from a UI wrapper layer dependent on third-party models toward custom model development to build a deeper technical moat