Composer 2

Overview

Composer 2, released on March 19, 2026, is the proprietary backbone of Cursor 3, the world's first agent-native IDE. Developed by Anysphere, Composer 2 is specifically engineered for long-horizon software engineering tasks that require hundreds of sequential actions across multi-repo workspaces. Unlike previous versions that relied solely on reinforcement learning, Composer 2 utilizes a novel "continued pretraining" approach to ensure a more robust understanding of codebase abstractions and technical logic.

In Cursor 3 (released April 2026), Composer 2 powers the revolutionary Agents Window, enabling developers to orchestrate a fleet of parallel agents to build, test, and deploy entire features autonomously. It is optimized for use with Bugbot, a self-improving system that learns from production feedback and pull request reviews.

Capabilities

Composer 2 represents a new tier of agentic intelligence:

• Long-Horizon Planning: Capable of executing hundreds of tool actions in a single session without losing coherence.
• Multi-Repo Context: Natively understands and operates across multiple repositories simultaneously.
• MCP & Skill Integration: Leverages the Model Context Protocol (MCP) to use external skills, custom subagents, and third-party tools.
• Bugbot Orchestration: Drives autonomous debugging cycles, learning from linter errors, test failures, and PR comments.
• Canvases Integration: Dynamically creates and updates interactive artifacts, dashboards, and custom interfaces in the side panel.
• Ultra-Low Latency: The "Fast" variant delivers tokens nearly 5x faster than previous generation frontier models.

Technical Specifications

Composer is built with cutting-edge architecture optimized for speed and efficiency:

• Architecture: Mixture-of-experts (MoE) language model with expert parallelism
• Precision: Native MXFP8 training for faster inference without post-training quantization
• Context Support: Long-context generation and understanding capabilities
• Training Method: Reinforcement learning (RL) in diverse development environments
• Training Infrastructure: Custom infrastructure built with PyTorch and Ray for asynchronous reinforcement learning at scale
• Scalability: Trained across thousands of NVIDIA GPUs with minimal communication cost using hybrid sharded data parallelism
• Tool Access: Full access to Cursor Agent harness tools including file editing, semantic search, terminal commands, and grep
• Training Environment: Hundreds of thousands of concurrent sandboxed coding environments in the cloud
• Inference Speed: Four times faster token generation compared to similar models

Architecture

Composer leverages advanced architecture and training techniques:

• Mixture-of-Experts: MoE architecture allows for efficient scaling and specialization
• Expert Parallelism: Distributed training across expert networks for optimal performance
• Hybrid Sharded Data Parallelism: Efficient data distribution for large-scale training
• MXFP8 Kernels: Custom MoE kernels for low-precision training and inference
• Asynchronous RL: Custom training infrastructure supporting asynchronous reinforcement learning at scale
• Virtual Machine Scheduler: Adapted infrastructure from Background Agents to support bursty training workloads
• Unified Environments: Seamless integration of RL training environments with production environments

Training Data

Composer was trained using a unique approach focused on real-world software engineering:

• Real-World Challenges: Trained on actual software engineering challenges from large codebases
• Diverse Environments: Training across a wide range of development environments and project types
• Production Tools: Access to production search and editing tools during training
• Optimal Solutions: Hand-curated optimal solutions to training problems for reinforcement learning
• Codebase Diversity: Exposure to various codebases, programming languages, and software engineering practices
• Problem Variety: Diverse range of difficult problems including code edits, planning, and informative responses

Performance Benchmarks

Composer 2 sets new records for AI coding agents:

• CursorBench: 61.3 (Standardized agentic correctness).
• SWE-bench Multilingual: 73.7 (State-of-the-art for multi-language software engineering).
• Terminal-Bench 2.0: 61.7 (Accuracy in CLI-based task execution).
• Generation Speed: Up to 400 tokens/sec in "Fast" mode.
• Tool Usage Accuracy: 98% accuracy in complex multi-repo file operations.

Use Cases

Composer is designed for a wide range of software engineering applications:

• Interactive Agentic Coding: Real-time coding assistance that keeps developers in the flow
• Large Codebase Navigation: Understanding and modifying complex, multi-file projects
• Code Generation: Generating code that follows existing patterns and conventions
• Refactoring: Updating code while maintaining codebase structure and abstractions
• Debugging: Identifying and fixing bugs across large codebases
• Feature Development: Implementing new features that integrate seamlessly with existing code
• Code Review: Analyzing code and suggesting improvements
• Test Writing: Creating and executing unit tests
• Documentation: Generating and updating code documentation
• API Integration: Working with external APIs and services
• Build System Management: Understanding and modifying build configurations
• Dependency Management: Managing project dependencies and imports

Limitations

While Composer excels at software engineering tasks, it has some limitations:

• Specialization: Optimized specifically for software engineering, may not perform as well on general language tasks
• Model Access: Currently available primarily through Cursor's platform
• Training Data: Knowledge limited to training data cutoff, may not include very recent technologies
• Complexity: Some extremely specialized or theoretical problems may require human intervention
• Context Limits: While supporting long context, extremely large codebases may still present challenges

Pricing & Access

Composer 2 is exclusively available within the Cursor 3 environment.

API Pricing (per 1M Tokens)

• Composer 2 Standard: $0.50 Input / $2.50 Output
• Composer 2 Fast: $1.50 Input / $7.50 Output

Subscription Access

• Cursor Pro ($20/mo): Unlimited Standard usage, 500 Fast requests/mo.
• Cursor Business ($40/user/mo): Unlimited Fast usage, priority support, and enterprise security.
• Cursor Enterprise: Custom SLAs, dedicated instances, and VPC deployment.

Ecosystem & Tools

Composer integrates seamlessly with Cursor's development ecosystem:

• Cursor IDE: Primary interface for using Composer
• Cursor Agent Harness: Full tool access including file editing, search, and terminal
• Semantic Search: Codebase-wide semantic search capabilities
• Terminal Integration: Direct terminal command execution
• File Operations: Reading, editing, and managing project files
• Grep Operations: String searching across codebases
• Linter Integration: Automatic linter error detection and fixing
• Test Execution: Writing and running unit tests

Community & Resources

• Composer Blog Post - Official announcement and technical details
• Cursor 2.0 Announcement - Overview of Cursor 2.0 features including Composer
• Cursor Documentation - Official documentation and guides
• Cursor Pricing - Current pricing information
• Cursor Changelog - Latest updates and improvements
• Cursor Forum - Community discussions and support
• Cursor Discord - Real-time community support