Whether you're looking for an angel investor, a growth advisor, or just want to connect — I'm always open to great ideas.
Get in TouchCursor launches Composer 2, an autonomous multi-file coding agent built on Kimi K2.5 that beats Claude Opus 4.6 on coding benchmarks at 86% lower cost — signaling a new era of agentic IDE tools with over 1 million daily active users.
AI, startups & growth insights. No spam.
Cursor has shipped Composer 2, an autonomous coding agent that can plan, write, and refactor code across multiple files without developer hand-holding — and it does so at 86% lower cost than Claude Opus 4.6 by running on Moonshot AI's Kimi K2.5 model. With over one million daily active users and Stripe signed on as an anchor enterprise customer, Cursor is making the clearest bid yet for the title of most important developer tool of the AI era.
When Cursor first launched Composer — its panel for multi-turn, context-aware coding — it was immediately one of the most talked-about IDE features in years. Developers could describe what they wanted, and Composer would generate and edit files while maintaining awareness of the broader codebase. It was impressive. But it was also fundamentally still a generation step: propose, review, accept or reject.
Composer 2 changes the operating model entirely.
The new version is built as an autonomous agent. Rather than waiting for a developer to approve each edit before moving to the next file, Composer 2 plans a full implementation strategy, executes across multiple files in sequence, runs the project's test suite, reads the output, and iterates until the task is complete — or until it surfaces a genuine blocker that requires human judgment. The loop is continuous, not conversational.
Concretely, the agent can handle tasks like: "Add Stripe webhook verification to our billing module, make sure all existing tests still pass, and write new tests for the new paths." A developer can describe the feature, switch to another task, and return to reviewed diffs and a passing test suite. That is a meaningfully different value proposition from anything that shipped under the Composer 1 banner.
The architecture underneath has changed as well. Composer 2 no longer relies exclusively on Anthropic's Claude models or OpenAI's GPT series for its reasoning backbone. Instead, Cursor has integrated Moonshot AI's Kimi K2.5 as the primary model for Composer 2 agent runs. The decision was driven by cost and performance simultaneously — a rare combination that does not often appear in enterprise AI procurement.
Cursor is also shipping deeper repository indexing with Composer 2. The system can now maintain context across repositories larger than 500,000 lines of code without losing coherence across a long agentic run. It does this through a hybrid retrieval layer that combines semantic embeddings with symbol-level graph traversal, meaning the agent understands not just what code says but how modules depend on each other. When Composer 2 modifies a utility function deep in a shared library, it can trace which consumers might break and address them proactively.
The most immediately striking number in the Composer 2 announcement is the cost figure: 86% cheaper than running the equivalent workload on Claude Opus 4.6 directly.
To understand why that number matters, you need to understand how token economics work in agentic workflows. A single Composer 2 task that spans four or five files and includes a test cycle might consume anywhere from 50,000 to 200,000 tokens across planning, execution, reflection, and revision steps. At Opus pricing, that adds up quickly — especially for engineering teams running dozens of agentic sessions per day across an organization.
Kimi K2.5 is a 1-trillion-parameter mixture-of-experts model developed by Moonshot AI, a Beijing-based AI lab backed by Alibaba and other Chinese institutional investors. The model is designed to activate only a fraction of its parameters for any given inference call, which dramatically reduces compute cost per token without sacrificing the depth of reasoning that large coding tasks require. Moonshot trained K2.5 heavily on code, mathematical reasoning, and long-context comprehension — the exact capabilities that multi-file coding agents need.
What makes the integration commercially interesting is that Kimi K2.5 performs at Opus-level on coding tasks specifically, even though it costs substantially less for general-purpose inference. Cursor is not paying Opus prices and accepting Sonnet-level output quality on coding. According to Cursor's own internal evaluation, the model matches or exceeds Opus 4.6 on the specific code generation and refactoring tasks that Composer 2 handles. That means the 86% cost reduction does not come with a quality penalty for the targeted use case.
For Cursor, this matters operationally. The company runs at massive scale — over a million daily active users generate an enormous volume of inference requests. Even small improvements in cost-per-task translate into eight-figure annual savings at that usage volume. Those savings give Cursor room to offer more generous usage limits under its subscription tiers, which is a meaningful competitive lever when other IDE tools are quietly throttling heavy users.
There is also a strategic signal here about how serious AI companies are beginning to think about model selection. The era of defaulting to the most capable frontier model for every task is ending. Cursor's decision to build Composer 2 on Kimi K2.5 rather than Claude or GPT-5 is a public statement that specialized, efficient models can outperform generalist giants on specific verticals — and that cost-performance optimization is now a first-class engineering decision, not an afterthought.
Cursor has released benchmark results across three standard coding evaluation suites: SWE-bench Verified (real-world GitHub issue resolution), HumanEval+ (function-level code generation), and a proprietary multi-file refactoring benchmark that Cursor developed internally to reflect the actual complexity of production codebases.
On SWE-bench Verified, Composer 2 powered by Kimi K2.5 resolves 62.4% of issues in the verified subset — compared to 58.9% for Claude Opus 4.6 and 61.1% for GPT-5.4. The improvement over Opus is modest in percentage terms but statistically significant given the size of the benchmark, and it holds consistently across web frameworks (Django, Rails, Express), compiled languages (Go, Rust, Java), and dynamically typed languages (Python, JavaScript, Ruby).
On HumanEval+, which tests correctness on 164 programming problems with augmented test cases designed to catch edge-case failures, Composer 2 scores 91.3% — slightly above GPT-5.4 at 90.8% and ahead of Opus 4.6 at 88.2%. The gap is not large, but it is directionally consistent with the SWE-bench results: Kimi K2.5's heavy code-focused training appears to give it an edge on tasks where precise syntax, correct API usage, and edge-case handling matter more than broad general reasoning.
The multi-file refactoring benchmark is where the results become most interesting. This suite presents the agent with a repository containing intentional architectural problems — circular dependencies, missing abstractions, inconsistent error handling patterns — and asks it to refactor toward a specified target architecture while keeping all existing tests green. Composer 2 completes 71% of refactoring tasks fully correctly. Standalone Claude Opus 4.6 (without Cursor's retrieval and orchestration layer) completes 47%. GPT-5.4 in a similar standalone configuration completes 52%.
The gap on multi-file refactoring is larger than the gap on the other benchmarks, and that discrepancy is probably not entirely attributable to the underlying model. Cursor's orchestration layer — the way Composer 2 structures its planning steps, uses the repository index, sequences file edits, and runs tests to verify progress — likely accounts for a significant portion of the advantage. The model is only part of the story. The agent scaffolding matters just as much.
That said, the numbers do reinforce a broader trend that Anthropic's own agentic coding research has been documenting: multi-agent architectures that break complex tasks into specialized sub-steps consistently outperform single-model, single-pass approaches, and the performance delta grows as task complexity increases.
The mechanics of Composer 2's autonomous operation are worth understanding in some detail, because "autonomous" can mean many things in AI marketing copy.
When a developer submits a task to Composer 2, the agent begins with an explicit planning phase. It reads the relevant files identified by Cursor's repository index, generates a structured plan that lists the files it intends to modify, the order of modifications, and the rationale for each change, and surfaces that plan to the developer before beginning execution. The developer can review the plan, reject it, or modify it. If approved — or if the developer has configured auto-approve for their project — execution begins.
During execution, the agent works through the plan sequentially. Each file modification is generated, validated against the agent's internal representation of the codebase state (updated in memory after each prior edit), and written to disk. The agent does not batch all changes and write them simultaneously; it updates its context after each file is modified, so later edits are aware of what earlier edits actually produced rather than what was originally planned.
After completing all planned file modifications, Composer 2 triggers the project's test runner — currently supporting Jest, pytest, Go test, RSpec, and Cargo test, with Maven and Gradle in beta. It reads the test output, identifies failures, traces them back to specific edits, and enters a repair loop. The repair loop runs up to a configurable maximum number of iterations (default: three) before surfacing remaining failures to the developer with a diagnostic summary.
Throughout this process, Composer 2 maintains a structured log that developers can inspect at any point. The log shows which files were read, which were modified, what the test results were at each iteration, and what reasoning the agent used when it encountered a failure and decided how to fix it. This transparency is important — it is what differentiates a coding agent that developers can trust and audit from a black box that produces output of uncertain provenance.
The system also implements a "scope guard" that prevents the agent from modifying files outside the set identified in its initial plan without explicit confirmation. This addresses one of the most common complaints about early coding agents: the tendency to make broad, sweeping changes that touch files the developer did not intend to include, creating hard-to-review diffs. AI coding agents that modify database schemas autonomously have been a particular source of incidents, and Cursor's scope guard is a direct response to that class of problem.
Cursor crossed one million daily active users in early 2026, making it one of the fastest-growing developer tools in history by that metric. For context, GitHub Copilot took approximately eighteen months to reach comparable daily active usage after its public launch; Cursor has grown faster in a more competitive market.
The company is reportedly running at a $2 billion annual revenue run rate, driven primarily by its Pro subscription at $20 per month and its Business tier at $40 per month per seat. At those price points, reaching $2 billion ARR requires roughly 4-8 million paying subscribers depending on tier mix — a figure that tracks with the daily active user count if the conversion rate from free to paid falls in a typical SaaS range.
Stripe's adoption of Cursor is the headline enterprise win in the Composer 2 announcement. Stripe is not just a marquee logo — it is a company with one of the most sophisticated engineering cultures in the industry, an enormous codebase spanning millions of lines of code across dozens of services, and an exceptionally high bar for developer tooling. The fact that Stripe has deployed Cursor at scale internally signals that the product has cleared a quality threshold that many early-stage coding tools do not reach.
Stripe's engineering team has reportedly been using Cursor for both greenfield feature development and legacy refactoring work. The latter is particularly telling: refactoring decade-old payment processing code is the kind of task where errors carry real financial and regulatory consequences, and it requires exactly the kind of careful, multi-file reasoning that Composer 2 is designed to handle.
Other enterprise customers in Cursor's announced roster include several Fortune 500 companies that have not been named publicly but have reportedly standardized Cursor as their approved IDE for all software development roles. The enterprise segment is growing faster than the individual Pro segment in absolute revenue terms, which is the typical trajectory for developer tools that achieve product-market fit in the individual user market before crossing into organizational adoption.
Cursor is not operating in a vacuum. The agentic coding market has attracted serious competition from multiple directions simultaneously.
Windsurf — formerly Codeium — has been the most direct competitor. Windsurf's Cascade agent offers similar multi-file autonomous editing capabilities, and the company has competed aggressively on price and on model flexibility, allowing users to plug in their own API keys for various frontier models. Windsurf's approach prioritizes user control over the model selection; Cursor's Composer 2 launch signals a different philosophy — Cursor controls the model selection to optimize cost and performance, and users trust the platform to make good choices.
GitHub Copilot has the distribution advantage that comes with being a Microsoft product integrated directly into VS Code and Visual Studio. Copilot has expanded aggressively, adding multi-file editing features and autonomous task completion through its Copilot Workspace product. But Copilot's architecture still feels closer to an enhanced autocomplete tool than a true agent; Copilot Workspace requires more manual orchestration from the developer, and the feedback loop between code generation and test execution is less tightly integrated than in Composer 2.
Replit's $400 million Series D positions it as the platform for agentic coding in the cloud rather than in a local IDE. Replit's bet is that the agentic coding workflow eventually migrates away from local machines entirely — that developers will describe software in natural language and have agents build, deploy, and iterate on it in cloud environments. Cursor's bet is that the local IDE remains the home of professional software development for the foreseeable future, even as agents take over more of the implementation work. Both bets could be partially right.
Amazon's Q Developer (formerly CodeWhisperer) is the enterprise-focused offering with deep AWS integration, positioned primarily at organizations already running on AWS infrastructure. JetBrains has been building autonomous coding features into its IDEs as well. The market is genuinely crowded, which makes Cursor's traction numbers and the Stripe win more impressive — differentiation in this space is hard.
The practical implications of Composer 2 for working developers are significant but require some nuance to assess accurately.
For individual developers, the most immediate change is that the effort-to-output ratio on medium-complexity tasks shifts dramatically. Writing a new API endpoint that integrates with an existing service, adding comprehensive error handling to a module that currently lacks it, migrating a component from one state management library to another — these are tasks that previously required sustained attention and careful manual execution. With Composer 2, they become describe-and-review tasks. The developer's job shifts from implementation to specification and verification.
That shift has implications for skill development that the industry has not fully worked out. If junior developers use autonomous coding agents throughout their early careers, they will develop strong skills in reading and evaluating code but potentially weaker skills in the deliberate, methodical debugging and systems thinking that comes from having to write everything by hand. This is not a reason to avoid the tools — the productivity gains are real — but it is a reason for engineering organizations to think carefully about how they structure learning and mentorship alongside tool adoption.
For engineering teams, the staffing implications are the harder conversation. Cursor's own internal data suggests that experienced engineers using Composer 2 can complete features in 40-60% less wall-clock time on medium-complexity tasks. If that figure holds at scale — and early enterprise adoption data suggests it broadly does — then the output capacity per engineer increases substantially without requiring additional headcount. Organizations have two choices with that capacity: produce more software, or produce the same software with fewer people. Both responses are happening in different companies right now.
The audit and review processes that engineering teams rely on also need to evolve. Reviewing a diff generated by a human engineer involves a specific kind of judgment — understanding what the engineer was trying to do, checking whether they achieved it, and catching the characteristic errors that humans make. Reviewing a diff generated by an autonomous agent requires different attention. Agents make different kinds of mistakes than humans do: they are more consistent at the mechanical level but can make structurally wrong decisions that a human reviewer needs to catch, especially at the boundary between what was specified and what was intended.
There is a reasonable argument that coding agents are the single most important application category in the current wave of AI development — not because software is uniquely important compared to other domains, but because coding agents demonstrate something about AI capabilities that matters for every other domain.
Writing code is, structurally, one of the hardest tasks for AI systems to fake. Code either executes correctly or it does not. Test suites either pass or they fail. The feedback loop is unambiguous in a way that is rare in AI-assisted work. When Composer 2 achieves a 71% success rate on multi-file refactoring tasks with passing tests, that is a hard number with no subjective interpretation. The agent actually fixed the code.
This is why the progress in agentic coding benchmarks like SWE-bench matters beyond the software industry. SWE-bench measures something close to general problem-solving ability in a constrained environment: the ability to read a complex system, understand what is broken, formulate a plan, execute that plan, and verify the result. The skills that transfer from solving SWE-bench problems well are the same skills needed for scientific research, legal analysis, engineering design, and most other high-value cognitive work.
Cursor's Composer 2 launch is a data point in an accelerating trend. The agentic coding capabilities that Anthropic has been documenting across its model family show consistent improvement quarter over quarter. The infrastructure for building, deploying, and managing coding agents is maturing rapidly. The business models — SaaS subscriptions, enterprise seat licenses, usage-based billing for heavy agent workloads — are proving out in the market.
What Cursor has built with Composer 2 is not just a better IDE feature. It is an early instantiation of a new category: software that builds software, supervised by humans who specify, review, and direct rather than implement. The category will grow. The tools will improve. The 86% cost reduction enabled by Kimi K2.5 today hints at what becomes possible when competitive pressure forces continued efficiency gains across the model landscape.
For developers, the practical advice is to engage seriously with these tools rather than waiting for a more mature moment. The teams developing fluency with agentic coding workflows now are building a skill set — in specification writing, agent orchestration, review and verification — that will be foundational for software development within the next two to three years.
What is Cursor Composer 2 and how is it different from the original Composer?
Composer 2 is an autonomous multi-file coding agent built into the Cursor IDE. Unlike the original Composer, which generated code edits for developer review at each step, Composer 2 operates in a continuous loop: it plans a full implementation strategy, executes edits across multiple files in sequence, runs the project's test suite, reads the results, and iterates until the task is complete or a genuine blocker requires human input. The developer reviews the final diffs rather than approving each intermediate step.
Why did Cursor choose Kimi K2.5 over Claude or GPT models?
Cursor selected Kimi K2.5 from Moonshot AI because it matches or exceeds Claude Opus 4.6 on coding-specific benchmarks while costing 86% less per inference. For a product running at over one million daily active users, that cost differential is operationally significant. Kimi K2.5 is a 1-trillion-parameter mixture-of-experts model with heavy training on code and mathematical reasoning, which aligns well with the specific task profile of autonomous coding.
Is Composer 2 safe to use on production codebases?
Cursor has implemented a scope guard that prevents the agent from modifying files outside the set it identified in its initial plan without explicit developer confirmation. The system also maintains a full audit log of every file read, every edit made, and every test result observed during an agent run. That said, as with any autonomous coding tool, developers should review diffs carefully before merging, particularly for tasks that touch security-sensitive code paths, database schemas, or authentication logic.
How does Cursor's pricing work for Composer 2 usage?
Composer 2 is available on Cursor's Pro plan ($20/month) and Business plan ($40/month per seat). Heavy agentic usage — tasks that consume very large numbers of tokens across long multi-file runs — may count against monthly usage limits depending on plan tier. Cursor has indicated that the efficiency gains from Kimi K2.5 allow them to offer more generous limits than would be possible if Composer 2 ran exclusively on Claude Opus.
How does Composer 2 compare to GitHub Copilot Workspace?
Both products target autonomous multi-file coding, but they differ in architecture and integration. Composer 2 is a local IDE tool with tight integration into the Cursor codebase indexing system and automatic test execution. GitHub Copilot Workspace operates more as a cloud-based planning and scaffolding tool that generates implementation plans for developers to execute. Composer 2 currently shows stronger benchmark performance on SWE-bench Verified and is more tightly integrated with the test-driven verification loop that makes autonomous coding trustworthy in production environments.
Moonshot AI's Kimi K2.5 launches on Cloudflare Workers AI with 256K context and native tool calling — delivering 77% cost reduction and $2.4 million in annual savings for production workloads at the edge.
Jensen Huang hosts a GTC Day 3 panel with Harrison Chase (LangChain), leaders from A16Z, AI2, Cursor, and Thinking Machines Lab to debate where open models stand against frontier closed ones — and what it means for builders.
NVIDIA announces the Nemotron Coalition at GTC 2026 — uniting Black Forest Labs, Cursor, LangChain, Mistral AI, Perplexity, and others to collaboratively train open frontier models on NVIDIA DGX Cloud.