Introduction
The software development landscape is being reshaped by artificial intelligence, and a new entrant is pushing the envelope further. Cursor, a startup that has built a “vibe coding” platform around the idea of letting natural language drive code creation, has just released its first in‑house large language model, Composer. This model is not a generic chatbot or a code‑completion engine; it is a purpose‑built, reinforcement‑learned mixture‑of‑experts system that promises to be four times faster than comparable frontier models while maintaining a high level of reasoning across complex codebases. The announcement comes as part of Cursor’s 2.0 platform update, which introduces a multi‑agent interface and a suite of developer‑centric features that together create a tightly integrated, production‑ready environment for autonomous coding. In this post we unpack what Composer actually does, how it was engineered, and why its speed and agentic focus could change the way teams write software.
Main Content
The Vision Behind Composer
Cursor’s founders have long believed that the most useful AI for developers is one that behaves like a teammate rather than a passive suggestion box. The company’s earlier “vibe coding” experiments let users type a natural‑language prompt and receive code snippets from a variety of third‑party LLMs, including OpenAI’s GPT‑4 and Anthropic’s Claude. While those models were powerful, they were not tuned for the idiosyncrasies of real‑world engineering workflows: version control, dependency resolution, test harnesses, and the need to run code locally. Composer was built to fill that gap.
The core idea is simple yet ambitious: train a model inside the very environment it will later inhabit. Rather than feeding static code snippets into a language model, Cursor fed the model a living codebase, complete with file editors, semantic search, terminal commands, and a suite of production tools. Each training iteration became a miniature software‑engineering task—write a function, refactor a module, run unit tests, or fix a linter warning. By repeatedly solving such concrete problems, the model learned not only how to generate correct code but also how to orchestrate the tools that make a codebase functional.
Reinforcement Learning Meets Mixture‑of‑Experts
Composer’s architecture is a marriage of two cutting‑edge techniques. First, the model is a mixture‑of‑experts (MoE) network, meaning that a large base of parameters is divided into many specialist sub‑networks, each of which can be activated for a specific type of task or code pattern. This design allows the system to scale to billions of parameters without a proportional increase in inference cost, because only a subset of experts is consulted for any given prompt.
Second, the MoE is trained with reinforcement learning (RL). In RL, the model receives a reward signal that reflects how well it performs a task, rather than just matching a ground‑truth text. For Composer, the reward function was carefully engineered to balance correctness, speed, and resource usage. The model was rewarded for producing accurate edits in fewer steps, for choosing efficient tool calls, and for avoiding speculative or redundant responses. Over time, this led to emergent behaviours such as automatically running unit tests, fixing lint errors, and performing multi‑step searches across the codebase—all without explicit human instruction.
The combination of MoE and RL gives Composer a dual advantage: it can scale to the complexity of large codebases while remaining fast enough to feel responsive in a developer’s IDE.
Speed as a Trust Factor
Speed is not just a marketing point; it is a critical factor in developer trust. In early experiments, Cursor’s prototype called “Cheetah” proved that latency could be reduced to sub‑second levels for simple code completions. However, Cheetah was a proof‑of‑concept that prioritized speed over depth. Composer builds on that foundation by delivering the same low latency while adding multi‑step reasoning and broader task coverage.
Benchmark results from Cursor’s internal “Cursor Bench” suite show that Composer can generate at 250 tokens per second—twice the speed of leading fast‑inference models and four times faster than comparable frontier systems. Importantly, these numbers are achieved while maintaining a high level of coding intelligence, as measured by adherence to style conventions, abstraction usage, and engineering best practices. For a developer, this means that an AI agent can keep up with the pace of a human teammate, providing suggestions, refactorings, or even full feature implementations without the dreaded “wait for the model” pause.
Integration into Cursor 2.0
Composer is not a standalone product; it is the engine that powers Cursor’s new 2.0 platform. The update introduces a multi‑agent interface that allows up to eight agents to run in parallel, each isolated in its own workspace via git worktrees or remote machines. This design enables parallel experimentation: a developer can ask one agent to refactor a module, another to write tests, and a third to optimize performance, all at the same time. The platform then aggregates the diffs and lets the developer choose the best output.
Several new features in Cursor 2.0 further enhance Composer’s effectiveness. The in‑editor browser, now in general availability, lets agents run and test code directly inside the IDE, feeding DOM information back to the model. Improved code review aggregates diffs across multiple files, speeding up inspection. Sandboxed terminals isolate agent‑run shell commands for security, and voice mode adds speech‑to‑text controls for hands‑free interaction. Together, these tools create a seamless loop where Composer can write, test, and iterate on code without leaving the developer’s workflow.
Training Infrastructure and Efficiency
To train a model of Composer’s size and complexity, Cursor built a custom reinforcement‑learning infrastructure that blends 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 updates with minimal communication overhead. This setup allows the model to train natively at low precision without the need for post‑training quantization, which in turn improves inference speed.
Composer’s training also leveraged hundreds of thousands of sandboxed environments—each a self‑contained coding workspace running in the cloud. By dynamically scheduling these virtual machines through Cursor’s Background Agents infrastructure, the company could handle the bursty nature of RL workloads, where training episodes vary in length and resource demand.
Enterprise‑Ready Features
Beyond the technical marvel, Composer is designed with enterprise use in mind. Cursor has optimized its Language Server Protocols for faster diagnostics and navigation, especially in Python and TypeScript projects, reducing latency when the model interacts with large repositories. Enterprise customers gain administrative controls such as team rules, audit logs, and sandbox enforcement. Cursor’s Teams and Enterprise tiers also support pooled model usage, SAML/OIDC authentication, and analytics dashboards that let organizations monitor agent performance across teams.
Pricing for individual users ranges from free hobby tiers to an ultra tier at $200 per month, while business pricing starts at $40 per user per month for teams, with custom contracts for larger enterprises. This tiered approach ensures that both hobbyists and large organizations can access Composer’s capabilities.
Conclusion
Composer represents a significant step forward in AI‑assisted programming. By training a reinforcement‑learned mixture‑of‑experts model inside a real development environment, Cursor has produced an LLM that is not only fast but also deeply aligned with the practical realities of software engineering. The result is an autonomous agent that can plan, write, test, and review code in a way that feels natural to developers, all while maintaining the speed required for real‑time collaboration.
The implications are far‑reaching. For individual developers, Composer offers a way to accelerate routine tasks and reduce cognitive load. For teams, the multi‑agent architecture of Cursor 2.0 opens the door to parallel experimentation and rapid prototyping. And for enterprises, the robust infrastructure and governance features mean that AI can be integrated into existing pipelines without compromising security or compliance.
In a world where code is becoming increasingly complex and the demand for rapid delivery is relentless, Composer’s blend of speed, reasoning, and agentic design could become a cornerstone of next‑generation development workflows.
Call to Action
If you’re curious to see how Composer can transform your coding experience, sign up for a free Cursor account today and explore the 2.0 platform. Try out the new multi‑agent interface, experiment with the in‑editor browser, and let Composer refactor a module or write a new feature for you. For teams and enterprises, reach out to Cursor’s sales team to discuss custom deployment options, enterprise licensing, and how Composer can be integrated into your existing CI/CD pipelines. Embrace the future of coding—where AI is not a tool you use, but a teammate you collaborate with.
