Vibe coding platform Cursor releases first in-house LLM, Composer, promising 4X speed boost
The vibe coding tool Cursor, from launch Any atmospherehas Composer introducedthe first internal, proprietary major language coding 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, representing a new step in AI-assisted programming. It is already being used by Cursor’s own technical staff in daily development, indicating maturity and stability.
According to Cursor, Composer completes most interactions in less than 30 seconds while maintaining a high level of reasoning ability across large and complex codebases.
The model is described as four times faster than comparable intelligent systems and is trained for ‘agentic’ workflows, where autonomous coding agents collaboratively plan, write, test and review code.
Previously, Cursor supported “vibe coding,” which used AI to write or complete code based on natural language instructions from a user, even one who wasn’t trained in development. on top of other leading proprietary LLMs from OpenAI, Anthropic, Google and xAI, among others. These options are still available to users.
Benchmark results
Composer’s capabilities are benchmarked using “Cursor Bench”, an internal evaluation package derived from real developer agent requests. The benchmark measures not only correctness, but also the extent to which the model adheres to existing abstractions, style conventions and technical practices.
On this benchmark, Composer achieves boundary-level coding intelligence and generates simultaneously 250 tokens per second – about twice as fast as leading fast inference models and four times faster than comparable frontier systems.
Cursor’s published comparison groups models into several categories: “Best Open” (e.g. Qwen Coder, GLM 4.6), “Fast Frontier” (Haiku 4.5, Gemini Flash 2.5), “Frontier 7/2025” (the strongest model available mid-year) and “Best Frontier” (including GPT-5 and Claude Sonnet 4.5). Composer matches the intelligence of mid-range systems while delivering the fastest recorded generation speed of any class tested.
A model built with reinforcement learning and architecture from a mix of experts
Cursor research scientist Sasha Rush provided insight into the model’s development messages on the social network Xwhere Composer is described as a reinforcement learned (RL) mixture of experts (MoE) model:
“We used RL to train a large MoE model to be very good at coding in the real world, and very fast too.”
Rush explained that the team co-designed both the Composer and Cursor environments to make the model run efficiently at production scale:
“Unlike other ML systems, you can’t abstract much from the entire system. We designed this project and Cursor together to run the agent at the necessary scale.”
Composer was trained on real software engineering tasks rather than static data sets. During the training, the model worked within entire codebases using a range of production tools (including file editing, semantic search and terminal commands) to solve complex technical problems. Each training iteration required solving a concrete challenge, such as making a code edit, creating a plan, or generating a targeted explanation.
The gain loop optimized both correctness and efficiency. Composer learned to make effective tool choices, use parallelism and avoid unnecessary or speculative responses. Over time, the model developed emergent behaviors such as running unit tests, resolving linter errors, and autonomously running multi-step code searches.
This design allows Composer to operate within the same runtime context as the end user, making it more suited to real-world coding conditions: dealing with version control, dependency management, and iterative testing.
From prototype to production
The composer’s development followed an earlier internal prototype known as Cheetahwhich used Cursor to investigate low-latency inference for coding tasks.
“Cheetah was the v0 of this model, mainly to test speed,” Rush said on X. “Our stats say so [Composer] is the same speed, but much, much smarter.”
Cheetah’s success in reducing latency helped Cursor identify speed as a key factor for developer confidence and usability.
The composer maintains that responsiveness while significantly improving reasoning and task generalization.
Developers who used Cheetah during initial testing noted that its speed changed the way they worked. One user commented that it was “so fast that I could stay on top of things while working with it.”
Composer keeps that speed, but expands its capabilities to include 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 agentic development environment.
The platform introduces a multi-agent interface, allowing up to eight agents that can run in parallel, each in an isolated workspace using git worktrees or remote machines.
Within this system, Composer can serve as one or more of these agents, performing tasks independently or collaboratively. Developers can compare multiple results from concurrent agent executions and select the best output.
Cursor 2.0 also includes supporting features that increase Composer’s effectiveness:
-
Browser in the editor (GA) – allows agents to run and test their code directly in the IDE, passing DOM information to the model.
-
Improved code review – collects diffs across multiple files for faster inspection of model-generated changes.
-
Sandbox Terminals (GA) – Isolate agent-executed shell commands for secure local execution.
-
Voice mode – adds speech-to-text controls for initiating or managing agent sessions.
While these platform updates expand the overall Cursor experience, Composer is positioned as the technical core that enables fast, reliable agentic coding.
Infrastructure and training systems
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 specialized MXFP8 MoE kernels and hybrid sharded data parallelism, enabling large-scale model updates with minimal communications overhead.
This configuration allows Cursor to train low-precision models without the need for post-training quantization, improving both inference speed and efficiency.
The composer’s training was based on hundreds of thousands of concurrent sandbox environments (each a self-contained coding workspace) running in the cloud. The company has adapted its Background Agents infrastructure to dynamically schedule these virtual machines to support the fast-paced nature of large RL runs.
Enterprise use
Composer’s performance improvements are supported by infrastructure-level changes in Cursor’s code intelligence stack.
The company has optimized its Language Server Protocols (LSPs) for faster diagnostics and navigation, especially in Python and TypeScript projects. These changes reduce latency when Composer communicates with large repositories or generates updates to multiple files.
Enterprise users gain administrative control over Composer and other agents through team rules, audit logs, and sandbox enforcement. Cursor’s Teams and Enterprise tiers also support pooled model usage, SAML/OIDC authentication, and analytics for monitoring agent performance in organizations.
Pricing for individual users ranges from Free (Hobby) to Ultra ($200/month), with extended usage limits for Pro+ and Ultra subscribers.
Business pricing starts at $40 per user per month for Teams, with enterprise contracts offering custom usage and compliance options.
The role of the composer in the evolving AI coding landscape
The composer’s focus on speed, reinforcement learning, and integration with live coding workflows sets it apart from other AI development assistants like GitHub Copilot or Replit’s Agent.
Rather than serving as a passive suggestion engine, Composer is designed for continuous, agent-driven collaboration, where multiple autonomous systems communicate directly with a project’s codebase.
This model-level specialization – training AI to function within the real-world environment in which it will operate – represents an important step toward practical, autonomous software development. Composer is not only trained on text data or static code, but within a dynamic IDE that reflects production conditions.
Rush described this approach as essential for achieving reliability in the real world: the model not only learns how to generate code, but also how to integrate it into context, test it, and improve it.
What it means for business developers and Vibe Coding
With Composer, Cursor introduces more than a quick model: it implements an AI system optimized for real-world use, built to work within the same tools developers already rely on.
The combination of reinforcement learning, a mix of expert design, and tight product integration gives Composer a practical edge in speed and responsiveness, setting it apart from general language models.
While Cursor 2.0 provides the infrastructure for multi-agent collaboration, Composer is the core innovation that makes these workflows viable.
It’s the first coding model built specifically for production-level coding – and a first look at what everyday programming could look like if human developers and autonomous models share the same workspace.
