Startup Anysphere’s vibe coding tool Cursor has introduced Composer, its first in-house proprietary coding large-scale language model (LLM), as part of its Cursor 2.0 platform update.
Composer is designed to perform coding tasks quickly and accurately in production-scale environments and represents a new step in AI-assisted programming. It is already used by Cursor’s engineering staff in daily development and has shown maturity and stability.
According to Cursor, Composer completes most interactions with the following steps: less than 30 seconds While maintaining a high level of reasoning ability across large and complex codebases.
The model is said to be four times faster than similar intelligent systems and is trained for an “agent” workflow in which autonomous coding agents collaborate to plan, write, test, and review code.
Previously cursors were supported "vibe coding" — Use AI on top of leading proprietary LLMs like OpenAI, Anthropic, Google, and xAI to create or complete code based on natural language instructions from users (even those with no development training). These options will continue to be available to users.
Benchmark results
Composer functionality is benchmarked using: "cursor bench," Internal evaluation suite derived from actual developer agent requests. This benchmark measures not only accuracy but also whether the model adheres to existing abstractions, style conventions, and engineering practices.
In this benchmark, Composer generates 250 tokens per second while delivering frontier-level coding intelligence. This is approximately twice as fast as leading fast inference models and four times as fast as comparable Frontier systems.
The comparison published by Cursor groups the models into several categories. “Best Open” (including Qwen Coder, GLM 4.6), “Fast Frontier” (Haiku 4.5, Gemini Flash 2.5), “Frontier 7/2025” (the most powerful model available mid-year), “Best Frontier” (including GPT-5 and Claude Sonnet 4.5). Composer matches the intelligence of mid-frontier systems and delivers record production speeds of all classes tested.
Model built with mixed reinforcement learning and expert architecture
Cursor research scientist Sasha Rush provided insight into the model’s development in a post on Social Network X, describing Composer as a reinforcement learning (RL) mixed-of-experts (MoE) model.
“We used RL to train a large-scale MoE model that became very good at real-world coding and very fast.”
Rush explained that the team co-designed both the Composer and Cursor environments so that the model could run efficiently at production scale.
“Unlike other ML systems, you can’t abstract much away from a full-scale system. We co-designed this project and Cursor to be able to run agents at the scale we need.”
Composer was trained on real software engineering tasks rather than static datasets. During training, the model worked within a complete codebase using a set of operational tools such as file editing, semantic search, and terminal commands to solve complex engineering problems. Each iteration of the training involved solving specific challenges, such as creating code edits, drafting plans, and generating targeted instructions.
The reinforcement loop has been optimized for both accuracy and efficiency. Composer has learned to choose effective tools, use parallelism, and avoid unnecessary or speculative responses. Over time, the model developed new behaviors such as running unit tests, fixing linter errors, and performing multi-step code searches autonomously.
This design allows Composer to operate within the same runtime context as the end user, making it more aligned with real-world coding requirements such as handling version control, dependency management, and iterative testing.
From prototype to mass production
The development of Composer followed an early internal prototype known as . cheetahCursor used this to explore low-latency inference for coding tasks.
“Cheetah was the v0 of this model primarily to test speed,” Rush told X. “By our metrics, Cheetah (Composer) is just as fast, but much smarter.”
Cheetah’s success in reducing latency led Cursor to recognize that speed is a key factor in developer confidence and ease of use.
Composer significantly improves inference and task generalization while maintaining its responsiveness.
Developers who used Cheetah during early testing noted that its speed changed the way they worked. One user commented, “It’s so fast that I always stay up to date as I work.”
Composer maintains its speed while extending its capabilities to multi-step coding, refactoring, and testing tasks.
Integration with Cursor 2.0
Composer is fully integrated into Cursor 2.0, a major update to the company’s agent development environment.
This platform introduces a multi-agent interface and You can run up to 8 agents in parallel. Each is in a separate workspace using git worktree or a remote machine.
Within this system, Composer can act as one or more of these agents and perform tasks independently or collaboratively. Developers can compare results from multiple concurrent executions of agents and choose the best output.
Cursor 2.0 also includes support features that increase the effectiveness of Composer.
-
In-editor browser (GA) – Enables the agent to run and test code directly within the IDE and transfer DOM information to the model.
-
Improved code reviews – Aggregate differences across multiple files to more quickly inspect changes produced by your model.
-
Sandbox terminal (GA) – Isolate shell commands executed by the agent for safe local execution.
-
audio mode – Add speech-to-text controls to start or manage agent sessions.
While these platform updates enhance the overall Cursor experience, Composer is positioned as the technical core that enables fast and reliable agent coding.
Infrastructure and training system
To train Composer at scale, Cursor built a custom reinforcement learning infrastructure that combines PyTorch and Ray for asynchronous training across thousands of NVIDIA GPUs.
The team developed a specialized MXFP8 MoE kernel and hybrid shard data parallelism to enable large-scale model updates with minimal communication overhead.
This configuration allows Cursor to natively train models at lower precision without the need for post-training quantization, increasing both inference speed and efficiency.
Composer training relied on hundreds of thousands of concurrent sandbox environments, each a self-contained coding workspace, running on the cloud. The company adapted its background agent infrastructure to dynamically schedule these virtual machines and support the bursty nature of large-scale RL executions.
Enterprise use
Composer performance improvements are supported by infrastructure-level changes across Cursor’s code intelligence stack.
The company has optimized the Language Server Protocol (LSP) to speed up diagnostics and navigation, especially in Python and TypeScript projects. These changes reduce latency when Composer interacts with large repositories or generates updates for multiple files.
Enterprise users gain administrative control over Composer and other agents through team rules, audit logging, and sandbox enforcement. Cursor’s Teams and Enterprise tiers also support the use of pooled models, SAML/OIDC authentication, and analytics to monitor agent performance across your organization.
Pricing for individual users ranges from Free (Hobby) to Ultra ($200 per month), with expanded usage limits for Pro+ and Ultra subscribers.
Business pricing for Teams starts at $40 per user per month, with enterprise agreements offering custom usage and compliance options.
Composer’s role in the evolving AI coding environment
Composer is different from other AI development assistants like GitHub Copilot and Replit’s Agent because of its focus on speed, reinforcement learning, and integration with live coding workflows.
Rather than acting as a passive suggestion engine, Composer is designed for continuous, agent-driven collaboration, where multiple autonomous systems interact directly with a project’s codebase.
This model-level specialization, or training an AI to function within the real-world environment in which it operates, is an important step toward practical autonomous software development. Rather than being trained solely on text data or static code, Composer is trained within a dynamic IDE that mirrors your production environment.
Rush explained that this approach is essential to achieving real-world reliability. The model not only learns how to generate code, but also how to integrate, test, and improve it in context.
What it means for enterprise developers and Vibe coding
With Composer, Cursor is introducing more than just a fast model. We’re deploying AI systems that are optimized for real-world use and built to work within the same tools that developers already rely on.
The combination of reinforcement learning, mixed-expert design, and tight product integration gives Composer a practical advantage in speed and responsiveness that sets it apart from general-purpose language models.
While Cursor 2.0 provides the infrastructure for multi-agent collaboration, Composer is the core innovation that enables these workflows.
It’s the first coding model built specifically for production-level coding for agents, and provides an early glimpse into what day-to-day programming can look like when human developers and autonomous models share the same workspace.
