Composer

Cursor's fast agentic coding model optimized for software engineering with 4x faster generation speed and specialized reinforcement learning training.

ComposerCursorAnysphereCode ModelAgent ModelMoESoftware EngineeringRL
Developer
Anysphere
Type
Code Model
License
Proprietary
🌐 Official Website💰 Pricing & API

Overview

Composer is Cursor's new agent model designed specifically for software engineering intelligence and speed. Released on October 29, 2025 as part of Cursor 2.0, Composer achieves frontier coding results with generation speed four times faster than similar models. The model is optimized for high-speed use as an agent in Cursor, making it ideal for interactive development workflows where speed and intelligence are both critical.

The development of Composer was motivated by Cursor's experience building Cursor Tab, their custom completion model. The team found that developers often want the smartest model that can support interactive use, keeping them in the flow of coding. Composer represents a smarter version of their prototype agent model (codenamed Cheetah), designed to keep coding delightful by being fast enough for an interactive experience.

Capabilities

Composer demonstrates exceptional capabilities for software engineering tasks:

  • Fast Agentic Coding: Generates code four times faster than similar models while maintaining frontier-level performance
  • Codebase Understanding: Deep understanding of large codebases with ability to navigate and modify complex project structures
  • Tool Integration: Seamless use of development tools including file editing, semantic search, terminal commands, and grep operations
  • Long-Context Processing: Supports long-context generation and understanding for working with extensive codebases
  • Intelligent Code Generation: Produces code that adheres to existing codebase abstractions and software engineering practices
  • Parallel Execution: Maximizes parallelism in tool use for efficient problem-solving
  • Autonomous Problem Solving: Can work independently on complex software engineering challenges from start to finish
  • Linter Integration: Learns to fix linter errors automatically during reinforcement learning training
  • Test Writing: Capable of writing and executing unit tests as part of its problem-solving workflow

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 demonstrates strong performance on software engineering evaluations:

  • Cursor Bench: Achieves frontier coding results on Cursor's internal benchmark
  • Correctness: High accuracy in solving real agent requests from engineers and researchers
  • Code Quality: Strong adherence to codebase's existing abstractions and software engineering practices
  • Speed: Four times faster generation speed compared to similar models in the "Fast Frontier" class
  • Tool Efficiency: Optimized tool use choices learned through reinforcement learning
  • Parallelism: Effective parallel execution of multiple operations
  • Response Quality: Minimized unnecessary responses and evidence-based claims

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 is available through Cursor's platform:

  • Cursor Integration: Built into Cursor 2.0 and later versions
  • Cursor Pro: Available with Cursor Pro subscription ($20/month)
  • Cursor Business: Included in Business plans ($40/user/month)
  • Cursor Enterprise: Available with Enterprise plans (custom pricing)
  • API Access: May be available through Cursor's API (check official documentation for latest information)

For the most current pricing and access information, visit Cursor's pricing page.

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

Frequently Asked Questions

Composer was released by Cursor on October 29, 2025 as part of Cursor 2.0.
Composer is specialized for software engineering through reinforcement learning, achieving frontier coding results with generation speed four times faster than similar models. It's optimized for interactive agentic coding workflows.
Composer is a mixture-of-experts (MoE) language model that supports long-context generation and understanding. It's trained natively at low precision using MXFP8 MoE kernels for faster inference.
Composer was trained using reinforcement learning in diverse development environments. The model was given access to production search and editing tools and tasked with solving real-world software engineering challenges in large codebases.
Composer has access to various tools including reading and editing files, terminal commands, codebase-wide semantic search, and grep operations. These tools enable it to efficiently solve complex coding problems.
Composer achieves frontier coding results on Cursor Bench, an evaluation consisting of real agent requests from engineers and researchers at Cursor, measuring correctness and adherence to codebase abstractions and software engineering practices. It performs comparably to models in the 'Fast Frontier' class while being four times faster.
Composer generates code four times faster than similar models while maintaining frontier-level coding performance, making it ideal for interactive development workflows.
Composer is designed for interactive agentic coding, software engineering tasks, code generation and editing, debugging, refactoring, and working with large codebases. It excels at maintaining codebase abstractions and following software engineering best practices.

Related Models

Claude Opus 4.1

Claude Opus 4.1 is Anthropic's most powerful AI model released in August 2025, excelling at complex reasoning, programming, and agentic tasks with 200K context window.

Claude Sonnet 4.5

Anthropic's latest high-performance AI model, delivering enhanced reasoning and improved performance for enterprise workloads and scaled AI applications.

DeepSeek V3.1

DeepSeek's first hybrid inference model, featuring 'Think' and 'Non-Think' modes to master both complex reasoning and general chat tasks.

Gemini 2.5

Google's latest and most advanced multimodal model, with enhanced reasoning, a 1M+ token context window, and improved performance.

GPT-5

OpenAI's most advanced language model with superior reasoning, multimodal capabilities, and enhanced safety features.

Llama 4

Meta's open-source family of AI models, featuring specialized versions like Scout and Maverick, designed to lead in reasoning, coding, and multimodality.

Explore More Models

Discover other AI models and compare their capabilities.

Browse Models← Back to Models