Cursor 3 and the new AI agent race for developers
The AI for coding market has entered a much more competitive phase, and Cursor 3 is Cursor’s bet to stay relevant in this new landscape. The company has rolled out a new AI agent-driven experience for software development, going head-to-head with tools like Anthropic’s Claude Code and solutions based on OpenAI Codex, which have gained millions of users in recent months.
According to Jonas Nelle, one of Cursor’s heads of engineering, the last few months have completely changed how devs work. A big chunk of the product that originally made Cursor successful — things like traditional autocomplete and in-IDE assistance — is no longer the core of the strategy. The new focus is clear: an environment where developers spend their day talking to agents, watching what they do, and reviewing the output, instead of manually writing every single line of code.
This shift doesn’t happen in a vacuum. Over the past 18 months, both OpenAI and Anthropic have launched their own coding agent products, backed by heavily subsidized subscription plans. That put direct pressure on Cursor’s business model, which until then had been one of the main ways devs accessed OpenAI, Anthropic, and Google models inside a specialized IDE.
What Cursor 3 actually is
Cursor 3 is described by the company itself as an agent-first product. Instead of only suggesting code inside the IDE, it puts AI agents at the center of the experience.
Everything happens inside the desktop app Cursor users already know, but now with a new interface dedicated to agents. In the center of the screen, there’s a simple text box that looks like a chatbot, where the dev types in natural language the task they want to delegate: build a new feature, refactor a module, fix a bug, write tests, improve performance, and so on.
When you hit Enter, the agent starts working without the dev needing to write a single line of starter code. The logic is very different from the classic “suggest a snippet of this function here”: the idea is true task offload, not just spot help. Meanwhile, in a sidebar on the left, the user can see and manage all agents currently running, including multiple agents in parallel, each handling a piece of the work.
What sets Cursor 3 apart from many desktop experiences built around Claude Code and Codex-based tools is the deep integration with the Cursor IDE itself. In a demo, Alexi Robbins, also co-head of engineering for Cursor 3, showed how an agent runs in the cloud to build a new feature, while the developer follows and reviews the generated code locally, directly in the project files.
In other words, it’s not just a separate chat window: it’s a workflow where the agent edits, creates, and suggests code in the real context of the repository, and the dev validates it line by line, just like reviewing a pull request.
Devs as architects and reviewers, not just typists
The vision behind Cursor 3 is to reshape the developer’s role. Instead of spending the whole day typing code, the dev acts more as an architect, reviewer, and orchestrator of tasks:
Receive the best innovation content in your email.
All the news, tips, trends, and resources you're looking for, delivered to your inbox.
By subscribing to the newsletter, you agree to receive communications from Método Viral. We are committed to always protecting and respecting your privacy.
- Defines goals and constraints for the agent.
- Monitors the execution plan.
- Checks the generated code and decides what actually lands in the repo.
- Combines multiple agents to handle different parts of the project.
This puts Cursor in the same evolutionary track as tools that are going beyond supercharged autocomplete. The focus is no longer just “writing faster” and shifts to delegating entire chunks of work, while keeping human oversight where it matters most: architecture decisions, user experience, technical quality, and product alignment.
How Cursor is trying to compete with the big AI labs
Behind this pivot toward an agent-first product, there’s also a hard business fight. Cursor is battling for the same AI-powered dev tooling space that giants like OpenAI and Anthropic are targeting, with far more capital to play with.
The company, which started as a practical way to code using third-party models, became one of those labs’ biggest customers. But as OpenAI and Anthropic started offering their own IDEs and code agents with aggressively subsidized subscriptions, Cursor’s edge got smaller.
Today, in some plans, devs can easily get more than $1,000 in model usage for just $200 a month. That makes tools like Claude Code and Codex-based solutions extremely attractive for heavy day-to-day AI usage.
Subscriptions, pricing, and community frustration
Until mid-2025, Cursor also offered a heavily subsidized plan for its core AI coding product. In June 2025, however, the startup announced it would switch to a usage-based pricing model, with rates tied to AI consumption, changing the math for many users.
The community’s reaction was loud, and the company itself later admitted that the communication wasn’t great. The decision, however, had a clear motivation: improve margins and find a sustainable path in a market where rivals can burn far more cash to acquire customers.
Meanwhile, Anthropic has already started tightening some of Claude Code’s subscription limits, signaling that the period of extreme subsidies may also have an expiration date. But for now, the combination of generous limits + a mature product still gives Claude Code and Codex-based tools an edge, according to several devs who migrated away from Cursor.
Why some devs switched
Developers interviewed by WIRED said they now use Claude Code and Codex for most of their AI work on code, pushing Cursor and similar tools into the background. The main reason isn’t just model quality, but:
- More generous usage limits included in the subscription.
- A well-integrated, agent-first experience with autonomous tasks.
- Strong cost-benefit considering the volume of tokens processed.
Some founders and tech leaders even mentioned that they now pick tools almost exclusively based on who offers the highest usage cap within the plan, since they run a lot of experiments, large refactors, and context-heavy tasks.
Proprietary models: the Composer line steps in
To avoid relying entirely on third-party models, Cursor has also started investing in its own family of models, called Composer. The latest release is Composer 2, built on top of an open-source system from Chinese AI lab Moonshot AI, which then received additional pretraining and post-training from Cursor’s team.
The idea is straightforward: offer a model with a good balance of performance, price, and speed that can be served more cost-effectively to its customer base. Instead of always paying full rates for external models, Cursor can, in many scenarios, route workloads to Composer 2, keeping costs down while still delivering a competitive AI coding experience.
The company’s stated plan is to go beyond adapting open-source bases and, in the future, train fully proprietary Composer models from scratch. That, however, requires very heavy investment in research, data, and infrastructure — something that historically has been more within reach of giants like OpenAI and Anthropic, which have raised tens of billions of dollars.
Training costs and the capital challenge
Training cutting-edge AI models is expensive, and everyone in the industry knows it. Top-tier GPUs, massive clusters, data engineering, research teams — it all weighs heavily on the balance sheet.
Cursor has a reputation for doing a lot with relatively few resources, keeping a lean team and shipping product fast. But the current race for high-quality code agents is probably the most expensive chapter in the company’s history. With OpenAI and Anthropic seeing this segment as a massive business opportunity, the pressure on Cursor to raise capital quickly is intense.
Unsurprisingly, the company is in talks for a new funding round at a valuation around $50 billion, almost double its valuation in the previous Series D round. The rapid growth, including physically, is visible: the San Francisco office has expanded so much that it now occupies a former movie theater, complete with neatly organized shoe racks at the entrance instead of the chaotic sneaker pile that marked the startup’s early days.
The agent-first world and Cursor’s place in it
With everyone rushing toward the agent-first model, what used to be a differentiator is now basically table stakes. Serious AI coding tools today need to handle:
- Long context across multiple files and folders.
- Complex refactors guided by the agent itself.
- Explaining code snippets in plain language.
- Generating and maintaining automated tests.
On top of this baseline, each player layers its own strategy: more autonomous agents, strong CI/CD integrations, a focus on security, deep support for specific stacks, or aggressive usage quotas under a flat subscription.
Cursor 3 is trying to stand out in two main areas:
- Deep integration between the cloud agent and the local IDE, with a continuous generate-and-review loop.
- A bet on an agent hub, where devs can see, manage, and track multiple agents side by side.
In the heads of engineering’s view, it doesn’t really matter whether the dev spends more time in the agent chat window or directly in the IDE. What matters is that they stay inside the Cursor ecosystem, using both experiences in a complementary way.
Hybrid teams: devs + agents
What’s becoming clearer is the shift from simple code assistants to hybrid teams. Instead of just speeding up what already existed, agents are starting to take on bigger responsibilities:
- Handling repetitive bug fixes.
- Refactoring long, painful legacy code.
- Generating initial documentation based on code.
- Updating dependencies and adapting old APIs to new versions.
The developer stays in control but spends less energy on mechanical tasks and more on decisions that demand product vision, user experience, system design, and business context. Tools like Cursor 3, Claude Code, and Codex-based stacks effectively become control panels for this fleet of agents.
What to expect from software development in the coming years
If 2023 and 2024 were the years when devs tested whether AI actually helped write code, 2025 and 2026 are shaping up to be the period when AI starts taking on a real share of the workload. The debate moves on from “does it work?” to questions like:
- How much work does it make sense to delegate to an agent?
- How do we guarantee quality, security, and maintainability?
- What’s the right balance between AI autonomy and human review?
Tools like Cursor 3 land exactly at this point: they don’t just prove that a code agent can ship a feature, they also provide mechanisms for supervision, transparency, and control inside the dev workflow. Detailed logs, clear visibility into changes, easy ways to roll back bad decisions, and tools to redirect agents become a key part of the experience.
In this context, the choice between Cursor, Claude Code, Codex, and other products stops being just about model preference and starts to involve team culture, project structure, usage limits, total cost, and even how the company organizes its review and deploy processes.
One thing, however, is getting very clear: the way software is written in 2026 is very different from what most devs learned back when everything was done line by line, by hand. Those who manage to ride this wave of code agents well — using tools like Cursor 3 in a conscious, strategic way — are likely to gain a real edge in productivity and technical quality, especially in large, complex, constantly evolving systems.
