Cursor Release Notes

On July 22, we launched Cursor Router with two new configurations, Auto Intelligence and Auto Balance

Since then, we have continued improving both modes as new models have arrived and our routing system has learned from more production traffic.

Today, Auto Intelligence delivers above Fable-level user satisfaction at 68% lower cost, a further 18% reduction since its launch. Auto Balance outperforms Opus 4.8 at 41% lower cost, a further 8% reduction over the same period, while further increasing user satisfaction by 3%.

We're working towards a Cursor Router that improves alongside the model frontier. This post explains how the current system works.

Cursor Router increases satisfaction and cuts cost vs. frontier models

Numbers in graph reported relative to Opus 4.8

A data-driven approach to routing

Cursor Router is built around the idea that model selection should be learned from how models perform on real developer work, rather than inferred from benchmark scores.

The router makes each decision using signals from the current turn and recent conversation state. These include structured features such as the task category, along with recent tool calls and the broader context of the work.

From there, routing happens in two parts.

First, we need to decide whether a turn is simple enough for a price-efficient model. Compass, our complexity predictor, makes this decision.

Second, if the turn is more demanding, we need to decide which frontier model is most likely to perform well on that kind of work. To make that decision, we classify the turn using a taxonomy of tasks, domains, and modifiers learned from real developer traffic.

Building a dataset

To develop the routing system, we first needed a dataset that reflected the conditions it would encounter in production. We built it from live Cursor traffic so it would preserve the actual mix of developer tasks, the context surrounding each turn, and the effects of switching between models.

As always, we respected users' privacy mode and data retention settings throughout this process.

The dataset contains hundreds of thousands of turns sampled across a range of models. Each datapoint includes the conversation signals available to the router, along with two outcomes we use to compare routing choices.

1. Performance. We infer performance from what the user does next. Moving on to the next task is a strong positive signal, while correcting the agent is a strong negative one.
2. Cost. We calculate cost from API pricing and token usage for that turn. Because the data comes from live traffic, it also captures costs that benchmarks often miss, including cache misses caused by switching models.

Predicting complexity with Compass

Compass estimates the complexity of each turn by predicting whether the user will be satisfied with Cursor's response. We train it on the performance signal mentioned above.

We use the resulting prediction as a proxy for complexity. This works because users rarely ask for corrections after simple tasks, like making a commit, while they're more likely to make follow-up requests when the work is more complex.

We evaluated Compass online and confirmed that its scores are strong predictors of user satisfaction. Turns that Compass rated as most likely to succeed received a positive performance signal 96% of the time, while turns it rated as least likely to succeed received one 71% of the time.

In practice, Compass assigns each turn a continuous complexity score between 0 and 1. We set a threshold within that range to determine which turns stay on a price-efficient model and which are upgraded to a frontier model. Lower thresholds keep more traffic on the price-efficient model, while higher thresholds upgrade more often.

Learning model strengths

After Compass tells us when a turn is complex enough to justify using a frontier model, the next question is which frontier model to use.

To answer it, we built a taxonomy from real developer traffic that describes each turn across three dimensions:

• Domains identify where the work happens: backend, database schemas, frontend
• Tasks identify what the developer wants done: fixing bugs, running commands, writing tests
• Modifiers capture characteristics that cut across domains and tasks, but may change which model performs best: bounded edits, product questions, visual-heavy changes

We then compare how different models perform across those categories. We found that no model dominates every kind of work, and each has categories where it outperforms:

• Grok offers strong value across broad, routine work. Its low inference cost made it especially effective for categories such as Git commands and general database operations.
• Sol performs especially well on planning and codebase comprehension. It also delivered strong results across several implementation tasks at a lower cost than other frontier models.
• Opus performs well on execution-heavy work. It showed particular strengths in devops, database queries, and performance optimization.
• Fable excels at debugging and visual implementation. Its quality gains were most valuable on complex tasks where they justified its higher cost.

Cursor Router uses those differences to match each turn to the model best suited to it.

Combining into an algorithm

Compass and the taxonomy play complementary roles. Compass estimates the model-agnostic complexity of the turn and compares that score with a routing threshold. Depending on where the score falls, we either send the turn to Grok, given its low inference cost, or use the taxonomy to identify the frontier model with the strongest observed performance on that kind of work.

When Compass does send a turn to the taxonomy router, model selection follows two rules:

1. Only route when performance is clearly better. A candidate model becomes eligible only when its observed performance on that task label clears a one-sided 75% uplift threshold against the price-efficient model. Roughly, this means we need 75% confidence that the improvement is real.
2. Choose the best mix within the budget. From the eligible candidates, the optimizer chooses the traffic-weighted combination expected to deliver the largest performance gain while keeping the average cost per turn within the mode's budget.

Together, the Compass threshold and the task router's cost budget define each mode's position on the cost-performance curve. Auto Balance keeps more traffic on the price-efficient path and gives the task router a smaller budget. Auto Intelligence gives the task router more room to select frontier models when the expected performance gain justifies the cost.

Evaluating performance in production

We evaluated our routing policies in two stages. First, we used cross-validation to tune the Compass thresholds and optimization budgets without overfitting to a particular split. We then evaluated the selected policies on a held-out test set that had not been used during training.

This gives us a more reliable estimate of how each policy should perform on new traffic. It helps us eliminate weak candidates and compare expected cost and performance before deployment. But offline analysis still cannot fully capture how a policy will behave in production, and benchmarks are limited for the same reason. Live developer traffic remains the most representative test.

Offline evaluation surfaces candidate policies to test online

*Cost and performance relative to Opus 4.8

We then tested the policies on live traffic, where we could measure user satisfaction and the actual cost of each turn under production conditions. This captures effects that are difficult to model offline, including token usage, caching, and the cost of switching between models.

Before launch, we tested both modes on live traffic and found that each improved the cost-performance tradeoff relative to individual frontier models. Auto Balance delivered higher satisfaction than Opus 4.8 at lower cost, while Auto Intelligence approached Fable-level satisfaction at a much lower cost.

We have since repeated this process as the routing system and available models have improved, moving both modes further beyond the cost-performance frontier.

Keeping pace with the model frontier

Since launching Cursor Router, we've added Opus 5 to the routing mix and improved Compass's predictions. That gives the router both a stronger set of models to choose from and a better signal for deciding when each one is worth using.

Over time, we want the router to become more adaptive by predicting each model's expected quality and cost, learning from production outcomes, and updating continuously. As the system improves, Cursor users will be able to benefit from frontier models where they're needed most, without paying frontier-model prices on every turn.

Read more in our docs.

Cursor can now read, write, and act across your Google Workspace.

New plugins give coding agents direct access to Gmail, Google Drive, and Calendar, so you can pull context, draft and update files, and manage your inbox and calendar without leaving Cursor.

Install plugins to connect:

• Google Drive: search files and folders, open and download content, create and organize files
• Gmail: search and read mail, draft and send messages, apply labels and manage threads
• Google Calendar: read schedules, create and update events, find free time

Browse the new plugins in the Cursor Marketplace or install them from the Customize page in Cursor. Learn more in our docs.

Cursor for iPad is now available on all paid plans.

New to both iPhone and iPad: an inbox to stay organized, and a review experience that covers the full PR. Create, review, and merge from anywhere.

Built for the bigger screen

The iPad layout is rebuilt around the extra space. Sidebar chats stay pinned so you can watch several agents run at once. Split screen keeps a review open next to a chat, and file diffs render in full.

Markup gets more room to work too. Attach a screenshot, then tap to drop a comment at a specific point, or draw directly on the image with Apple Pencil.

A full review surface

On iPhone and iPad, the review screen now covers the full PR: comments, checks, and approvals. Add or change reviewers, read comments, and prompt the agent to resolve them. The whole path from agent output to merged PR now travels with you.

Inbox

An Inbox helps you and your agents stay organized. See what's in progress, what needs your attention, and which PRs are in review.

Additional improvements for Cursor on iPhone and iPad

• Bitbucket and Azure DevOps SCM support
• Multi-PR sessions: when one chat creates multiple PRs, you can now open every one of them, not just the last.
• Switch between teams that you belong to directly in the app

Download the Cursor App or read our docs to learn more.

We're introducing Cursor Start, a new ₹649 monthly plan for developers in India, making daily agentic development accessible and payment easy with local pricing and UPI.

Existing Free users in India can upgrade their plan from the dashboard. New users in India can visit cursor.com/signup and select the Start plan during onboarding.

Start bills monthly with auto-renewal and is available from July 28, 2026.

Cursor Start includes:

• Generous access to Cursor models: Grok 4.5, our most powerful model, and Composer, our most price-efficient coding model, with enough usage to build with agents every day.
• Always-on cloud agents that build, test, and ship code while you keep working.
• Cursor for iOS with remote control, so you can launch and steer agents from your phone.
• Plugins, MCP servers, hooks, and skills to extend Cursor across your workflows.
• Local pricing at ₹649 per month, tax inclusive, billed in INR with UPI or card.

Learn more in our announcement and docs.

Today we're launching Cursor Start, a new plan for developers in India that includes generous access to Grok 4.5 and Composer for ₹649 per month.

India has one of the most ambitious and active developer communities in the world. Our user base in India has tripled in the past year to more than 3M developers, making it our third largest market globally. It is also home to more power users than any other market in the world, with developers in India running more agent requests per developer than anywhere else.

Behind those numbers are students shipping their first projects, founders building their companies, and engineers and designers at India's fastest-growing startups building ambitious software.

For a long time, our users in India have asked us for two things: pricing that reflects the local market, and the ability to pay with UPI. Cursor Start delivers both. It's a plan built to make agentic development in Cursor accessible, priced in INR at ₹649 per month, payable with UPI, and with generous usage for everyday building.

What's included in Start

Cursor Start gives developers in India expanded access to Cursor's models at a price built for the local market.

With Cursor Start, you get:

• Generous access to Cursor models. Run Grok 4.5, our most powerful Cursor model, and Composer, our most price-efficient coding model.
• More agent requests than the Free plan, across desktop, web, iOS, and the CLI, so you can build every day.
• Always-on cloud agents. Kick off long-running cloud agents that build, test, and open pull requests while you keep working.
• Cursor for iOS. Launch agents or control existing ones from your phone, then pick the work back up on your desktop.
• Extend Cursor across your workflow, with plugins, MCP servers, hooks, and skills.
• Local pricing. ₹649 per month, tax inclusive, billed monthly in INR with UPI or card.

Cursor Start sits between our two other individual plans, Free and Pro.

Free gives you a way to try Cursor with no payment required. It includes access to Composer and a limited number of local agent requests each month.

Pro is for developers who want access to every major model, including the most advanced ones from other labs, along with Bugbot, Auto mode, Automations, the Cursor SDK, and on-demand usage past the included limits. Cursor Start covers everyday building. When you need more, it's easy to change your plan to Pro.

To compare across all plans and see a more detailed view of what's included, visit cursor.com/pricing.

Getting started

Cursor Start is available today for developers in India at cursor.com/pricing.

Existing Free users in India can upgrade their plan from the dashboard. New users in India can visit cursor.com/signup and select the Start plan during onboarding. Pay in INR with UPI, credit, or debit card.

Auto mode is now powered by Cursor Router.

Cursor Router is our intelligent model router. It analyzes each request and sends it to the right model for the job. Frontier models handle work that demands them. Price-efficient models handle the rest.

Optimization modes

Select Auto, then choose how the router optimizes:

• Intelligence: Frontier quality, matching the most expensive and powerful models that might be out of reach for daily use.
• Balance: Strong quality, matching the frontier models that most people like to daily drive.
• Cost: Good quality, reaching the highest available intelligence while optimizing token spend.

Balance and Intelligence bill at the routed model’s rate. Each mode moves you along the cost-intelligence pareto frontier.

Admin controls

Admins can enable the router per team or group, restrict which optimization modes members can use, set the default mode, and allow or block underlying models.

Cursor Router is available across desktop, web, iOS, CLI, and our SDK. It is on by default for Teams plans. Enterprise admins can enable it from the dashboard.

Learn more in our announcement and docs.

Today we're launching Cursor Router, our intelligent model router for teams and enterprises.

Cursor Router lets teams automatically route every request to the most capable model for the task, delivering frontier intelligence at a lower cost.

We've observed incredibly strong results on production traffic across thousands of enterprise developers. During our early access period with dozens of enterprises, customers got frontier performance at approximately 30–50% lower cost.

In online A/B tests across millions of requests, Cursor Router delivered frontier-quality performance at 60% savings.

Cursor routes hundreds of millions of coding requests each week across every model and provider, with unique visibility into what users like and what stays in the codebase. Model neutrality has always been core to how Cursor works, and today we're putting that data and expertise to work for your team.

With Cursor Router, our goal is to provide teams with the best performance and experience for every task, without spending more than the work requires.

How it works

Roughly 60% of developers using Cursor pick a single model as their daily driver. This results in routine work being completed at frontier prices, and AI spend growing much faster than output quality. Cursor Router fixes that by classifying each request before a model runs.

At its core, Cursor Router is a classifier that routes users to the best model option based on their query. We trained Cursor Router on 600k+ live requests and evaluated performance in an online A/B test across millions of live requests directed by Cursor Router, optimizing for user satisfaction (AFC) as a reward.

Cursor Router analyzes each request on query, context, task complexity, and domain, combined with what we know about each model's behavior. We learn what each model is best at, and route to the most effective option. Simple work goes to the most price-efficient models, UI updates go to the model with the best taste, and more complex, long-horizon problems go to frontier reasoning models.

We designed our routing classifier for a world in which updated models get shipped early and often. This way as newer and more powerful models are released, we can easily update Cursor Router, so the experience keeps improving.

Cursor Router is cache-aware in both how it is trained and evaluated. It is trained on a dataset where routing results in cache misses, and evaluated in production where our reported cost savings include the cost of cache misses in routing decisions.

Frontier intelligence at lower cost

Cursor Router has three modes: Intelligence, Balance, and Cost which let you adjust where you are on the cost-intelligence Pareto frontier.

We found that Auto Intelligence mode lands near Fable on user satisfaction of output at about 60% lower cost for teams, while also lifting satisfaction about 15% over Opus 4.8 at nearly the same cost.

Similarly, Auto Balance lands above Opus 4.8 on user satisfaction with the results at about 36% lower cost. Against GPT-5.6 Sol, Auto Balance delivers comparable satisfaction at a lower spend rate.

We chose to measure the efficacy of our router using large online A/B tests instead of offline evals. While offline evals are useful proxies for quality, they're limited by their small size, their distance from real-world usage, and the difficulty of reducing success to a rubric.

Offline evals also omit the extra cache-miss cost that comes from switching models. Real routing happens across a conversation: which model to pick, and when to switch.

Online A/B tests put Cursor Router to test in the real world across millions of tasks and conversations. Engineers write code, ask follow-ups, hit errors, and keep going, often across hundreds of requests in a week. Those are the conditions under which a model router needs to perform well.

In terms of quality of output, we measured:

• User satisfaction, classifying agent success based on user responses. Moving on to the next feature is a strong positive signal, while correcting the agent is a strong negative one.
• Keep rate, or how much of the agent-generated code remains in the codebase over time.

We have relied on these metrics to evaluate every model launch and harness improvement in the past nine months.

What customers are seeing

Over the past two weeks, Cursor Router has been in early access with a selection of enterprise customers. We compared what they actually paid against the same traffic, priced entirely at Opus 4.8 API rates.

In early access, three high-volume accounts with thousands of users saved 30%–50% on Auto-routed requests versus routing everything to Opus 4.8, with no decrease in quality.

Cost per request is only half the story. Engineering leaders care whether those savings show up in real shipped work, so we looked at cost per commit, and the pattern held.

For a single commit, we observed Cursor Router had a lower cost per commit of $6.76 for Intelligence mode and $4.63 for Balance.

GPT-5.6 Sol matched the cost of Intelligence but had lower user satisfaction with the output. Meanwhile, Fable 5 and Opus 4.8 produced commits at a cost premium to Cursor Router at $12.69 and $7.34 respectively.

That gap is the practical case for routing. Cursor Router keeps hard tasks on the most capable models and moves routine work off of frontier pricing.

You choose the tradeoff

Cursor designed our router with teams and large organizations in mind. The router uses a data-driven taxonomy, while admins and end users can still choose where it sits on the cost-intelligence Pareto frontier.

Select Auto mode in the model picker, and choose from three optimization modes that move you along the frontier:

• Intelligence: Frontier quality, with performance matching the most expensive and powerful models that might be out of reach for daily use.
• Balance: Strong quality, with performance matching the frontier models that most people like to daily drive.
• Cost: Good quality, reaching the highest available intelligence while optimizing token spend.

Admins can decide how Cursor Router rolls out across teams. You can enable it per team or group, choose which modes members can select, set the default, and allow or block specific models.

What’s next

Cursor Router is one piece of how Cursor drives token efficiency. Choosing the right model only matters if the agent itself stays lean, so we keep cutting waste in the harness around it.

Dynamic tool calling is another clear example where most native tool descriptions are no longer loaded into every prompt. The model looks them up the first time it needs them, following the same pattern we already use for MCPs. This keeps common tools like read and edit hot while less commonly used tools only enter the prompt when the agent actually calls them.

Alongside Cursor Router, we keep raising the floor and the ceiling of the model pool: Grok 4.5 widens what Cursor Router can draw from on harder, higher-cost work. Composer keeps getting better on the everyday path, so lower cost turns stay close to frontier quality without paying frontier prices.

Cursor Router is available today for Teams and Enterprise plans across desktop, web, iOS, CLI, and our SDK.

Read more in our docs and changelog.

Cursor in Slack now shares a plan before it starts, runs in multi-repo environments, and can work across channels and threads.

Interaction improvements

Cursor now responds with a plan before it begins, so you can jump in and redirect early. As it works, it updates its status so you can follow each step.

We also refined how Cursor's responses look in Slack. In-message buttons are gone, replaced by compact footer links. Tables, PRs, and artifacts now render more cleanly.

Multi-repo environment support

From Slack, Cursor can now start in a named multi-repo environment instead of a single default repository. If your frontend, backend, and shared code live in separate repos, Cursor reads your request and targets the environment that gives it access to all of them.

Mid-task, when Cursor needs a repo outside the current environment, it prompts you with a Switch repository button. Click it, choose the repo or environment, and Cursor picks up right where it left off.

Cross-channel workflows

Cursor can now read from and send messages to other Slack channels and threads. During a task, it can pull context from elsewhere in the workspace and post updates back in the original thread or the relevant channel.

Learn more in our Slack docs.

This release makes it easier to stay in flow with side chats that run alongside your main chat, the ability to search agent transcripts, and simplified project and repo pickers.

Side chats

Open a side chat to ask questions, explore ideas, and investigate tangents without interrupting your main agent conversation. Use /side, /btw, or the plus button at the top of the chat panel to create a new side chat that has context from the main chat.

Each side chat is a durable, full agent conversation that you can follow up on, revisit later, and at-mention to pull context back into the main thread.

By default, side chats focus on reading, searching, and answering. Use them to ask clarification questions, research alternatives without committing to a pivot, and sanity-check a decision while the main agent continues running.

Conversation search

Find past agent chats faster with search results that go beyond names and PR numbers. In the Agents Window, you can search agent transcripts from the command palette (Cmd+K). Cursor builds a local search index that scales search to thousands of conversations with snappy performance.

You can also search within an existing conversation using Cmd+F. Jump between matches, see a match counter, and keep searching as you scroll through long transcripts.

Redesigned project and repo pickers

We've simplified the project and repo pickers and made them more powerful. You can now stay in the picker for workflows that used to send you elsewhere. For example, you can create a project and connect GitHub, GitLab, or Azure DevOps without leaving the picker.

Search is now scoped to where you're working—This Computer, Cloud, or a specific remote machine—instead of one global search box. You can also remove projects from Recents with one click.

New cloud agent hooks

Cloud agents already support team hooks around tool execution and file/shell work. We've added new hooks that let you observe and control the agent conversation itself: prompts, responses, thinking, subagents, compaction, and turn completion. See all the supported hooks in our docs.

New hooks like beforeSubmitPrompt, afterAgentResponse, afterAgentThought, stop, subagentStart, and more allow you to better observe output and reasoning, control subagents, and build self-correcting loops with cloud agents.

Today we are releasing Grok 4.5 together with SpaceXAI, our most intelligent model and the first we've built for more than software engineering.

Grok 4.5 can handle difficult, long-running tasks that require creatively using tools to solve problems, whether in software engineering, data science, finance, legal work, or anything else you do on a computer.

Cursor subscription plans for individuals and teams include significant usage of the model with double usage for the first week. We've also added new safeguards reflecting the model's cybersecurity capabilities.

A strong foundation

Grok 4.5 is a mixture-of-experts model that we trained jointly with SpaceXAI.

Training included trillions of tokens of Cursor data which capture a wide-range of user interactions with codebases and software tools. This dataset lets the model learn both from existing software as well as developer-agent interactions, capturing how developers work and how agents interact with their environments.

While we trained our previous model, Composer 2.5, to be a coding specialist, for Grok 4.5 we kept the training data mix deliberately broader. This involved drawing on high-quality STEM tasks, research papers, and other knowledge work, so that the model gained proficiency across a wide range of domains.

Reinforcement learning on difficult problems

We used reinforcement learning on difficult problems in realistic environments spanning both software engineering and broader knowledge work. These environments teach the model to investigate problems, use tools, recover from mistakes, and verify results.

Many of these problems had to be designed to be difficult enough that even frontier models fail at them. As models improve, existing tasks stop teaching them anything new, and problems that once required extensive reasoning become routine.

We developed a distributed agent system to construct these environments at scale. Engineers specify a problem and how a solution is verified, and large groups of agents construct, test, and refine each environment. Some would have taken teams of hundreds of engineers months to build. This is one of the ways in which we used the previous model to accelerate progress on the next model.

Get started with Grok 4.5

Grok 4.5 is available today in Cursor across desktop, web, iOS, CLI, and our SDK.

Individual and team plans include significant usage of the model as part of our first-party model pool, and we are doubling usage for the first week. The base model is priced at $2/M input tokens and $6/M output tokens. There is also a fast variant at $4/M input tokens and $18/M output tokens.

Grok 4.5 and Composer 2.5 are two different model weight classes, and we're excited to support both sizes and weights. Composer 2.5 will remain offered, and we will release new models of this size going forward.

SWE-Bench Pro and Terminal-Bench show self-reported scores for third-party models. For SWE-Bench multilingual, the GPT 5.5 score comes from our internal run.

Grok 4.5 has an advantage on CursorBench because an earlier snapshot of the Cursor codebase was accidentally included in training. The exact impact is unclear. That data has been removed for future models, and in parallel we are working on a larger update to CursorBench, hence the exclusion here.

As agentic coding spreads, the working life of a software engineer has become dazzlingly complex. A single engineer might oversee dozens of coding agents at once, launching and guiding different processes as necessary.

It’s a lot to keep track of, and human engineers’ attention has quickly become the limiting resource.

Cursor launched a new tool Thursday aimed at keeping that chaos in check. Called Automations, the new system gives users a way to automatically launch agents within their coding environment, triggered by a new addition to the codebase, a Slack message, or a simple timer. As Cursor describes it, it’s a way to review and maintain all the new code created by agentic tools — without tracking dozens of agents at once.

At the most basic level, Automations are a way for engineers to break out of the “prompt-and-monitor” dynamic that defines most agent-based engineering. Instead of launching agents with a human prompt, Cursor’s Automation framework lets you launch agents automatically — and loop humans in whenever they’re needed.

“It’s not that humans are completely out of the picture,” Jonas Nelle, Cursor’s engineering chief for asynchronous agents, told TechCrunch in an interview. ”It’s that they aren’t always initiating. They’re called in at the right points in this conveyor belt.”

One early example is Bugbot, a long-standing Cursor feature that the team sees as a predecessor to the broader Automation system. The Bugbot system is triggered every time an engineer makes an addition to the codebase and reviews the new code for bugs and other issues. Using Automations, Cursor has been able to expand that system to more involved security audits and more thorough reviews.

“This idea of thinking harder, spending more tokens to find harder issues, has been really valuable,” said engineering lead Josh Ma.

Cursor estimates that it runs hundreds of automations per hour, reaching far beyond simple code review. The system is also used for incident response, with PagerDuty incidents initiating an agent that can immediately query server logs through an MCP connection. A separate automation offers weekly summaries of changes to the codebase on Cursor’s company Slack.

“In the abstract, anything that an automation kicks off, a human could have also kicked off,” said Nelle. “But by making it automatic, you change the types of tasks that models can usefully do in a codebase.”

The new system comes amid intense competition in the agentic coding space, with both OpenAI and Anthropic having made significant updates to their agentic coding tools in the past month.

Ramp data shows Cursor’s market share holding steady since May, with roughly 25% of generative AI clients subscribing to Cursor in some capacity.

Still, the overall growth of the agentic coding space has kept the company’s revenue increasing at a stunning pace. Earlier this week, Bloomberg reported that Cursor’s annual revenue had grown to more than $2 billion, doubling over the past three months.

We've expanded team marketplaces to support Team MCPs and organization groups.

Admins can now configure Team MCP servers once and distribute them across cloud agents, the agents window, IDE, and CLI.

When an admin sets up Team MCP servers for cloud agents, they can make those same servers available in a team marketplace from Dashboard -> Integrations & MCP. This allows members of the team to install approved integrations locally without configuring servers themselves.

Learn more in the docs on migrating existing Team MCPs.

Team marketplaces now support organization groups, in addition to team-level SCIM directory groups.

Under Dashboard -> Plugins -> Team Marketplaces, restrict marketplace access to specific organization groups. Marketplaces that already use SCIM directory groups keep that configuration.

Get started in the Cursor dashboard.

Cursor is now available as a native iOS app in public beta, so you can build from anywhere.

Until now, developers have worked around the limits of their local machines, keeping laptops half-open and caffeinated everywhere they go.

With Cursor for iOS, you can launch always-on agents in the cloud, or control agents running on your computer from your phone. Kick them off when ideas strike, get notified when work is ready for review, and merge PRs on the go.

Whether your agents are running on your machine or in the cloud, you can move work forward from wherever you are.

Get Cursor for iOS

Launch and track agents from anywhere

Whether you're catching a flight, cooking a meal, or in between sets at the gym, you can now act on moments of inspiration or curiosity.

Open the Cursor mobile app, choose a repo, and launch an agent the same way you would on the desktop app. You can pick any frontier model, describe ideas out loud with voice input, and use slash commands to guide Cursor in the right direction.

For agents running on your computer, use Remote Control to continue directing them from your phone. To ensure your machine remains reachable while you're away from your desk, you can enable a setting that keeps your computer awake.

New ways of working from your phone

At Cursor, we use the mobile app for everything from small, well-scoped tasks to long-running projects. It has enabled new workflows for our team and early testers:

• Handling incidents while on call: When you get paged at lunch, you can kick off an agent to investigate and propose a fix. By the time you get back to your computer, you'll have a PR ready for review.
• Resolving customer issues: If a customer reports a time-sensitive bug while you're away from your desk, you can start an agent from your phone to reproduce the issue, inspect the relevant code, and work toward a fix.
• Acting on feedback from other mobile apps: When you see user feedback on X or other platforms, take a screenshot, annotate it, and send it to an agent as visual context. This is often the fastest way to start design or UI changes.

Stay in the loop

Once an agent starts, you can leave the app. Cursor keeps you updated with Live Activities on your lock screen and push notifications when an agent finishes, needs input, or is ready for review.

Beyond code, cloud agents produce demos, screenshots, and logs that make it easy to validate their work. When an agent is done, you can review these generated artifacts, inspect diffs, leave follow-up instructions, or merge the PR directly from the app.

Handoff between local and cloud

Cloud agents run in isolated virtual machines with full development environments to test, verify, and demo work. Since they operate asynchronously with their own tools and resources, cloud agents can run for longer and iterate toward merge-ready PRs without intervention.

To take advantage of these capabilities, send a local plan to a cloud agent or move active agents to the cloud to keep running. You can move the cloud session back to your computer to test changes locally before merging.

What's next

Over time, the experience of running agents in the cloud will become indistinguishable from running them on your local machine. Until then, we want to make it easy to work with agents across both environments with Remote Control and fluid handoffs between local and cloud.

We are also working on adding the ability to create repo-less chats to make it easier to kick off tasks that don't require codebase context. Teams are already using Cursor today with MCPs to query Datadog logs, summarize activity across Slack channels, and more.

Cursor for iOS is available now in public beta on all paid plans. Get 75% off on Composer 2.5 runs in the mobile app now through July 5, 2026.

Download for iOS to start building from your phone, or read the docs to learn more.

Cursor for iOS is now available in public beta on all paid plans. Launch and manage always-on agents from anywhere.

Cloud agents on mobile

Open the Cursor mobile app, choose a repo, and launch an agent the same way you would on the desktop app. Pick any frontier model, describe ideas out loud with voice input, and use slash commands to guide Cursor in the right direction.

Cloud agents run in isolated virtual machines with full development environments to test, verify, and demo work. Move sessions from local to cloud to keep them running with your laptop closed.

Remote Control

Use Remote Control to take an agent you're running on your computer and keep directing it from your phone.

You can also turn on a setting to keep your computer awake, so your machine stays reachable while you're away from your desk.

On Teams and Enterprise plans, admins must enable Remote Control from the Cursor Dashboard.

Live Activities and push notifications

Track the status of your agents with Live Activities on your lock screen. Get push notifications when an agent finishes, needs input, or is ready for review.

Artifacts and SCM

Review demos, screenshots, logs, and diffs from your phone. Leave follow-up instructions, or merge the PR directly from the app.

Download Cursor for iOS to start building from your phone. Read our announcement or the docs to learn more.

Plugins, skills, and MCPs

Plugins, skills, and MCPs let you customize Cursor for your workflows. The new Customize page brings them into one place.

You can now add and manage plugins, skills, MCPs, subagents, rules, commands, and hooks at the user, team, or workspace level, and even bring your own custom MCPs.

Marketplace leaderboard

Cursor now shows you a leaderboard of the most popular plugins, skills, and MCPs across your team.

Add any to your setup with one click from the new Customize page and extend Cursor for your workflow.

Plugin canvases

Plugins now support prebuilt canvases: shared setup templates your team can open and reuse.

Use the Hex Canvas to build data visualizations.

Use the Atlassian Canvas to see a realtime view of all our issues, projects, and documents.

New Team Marketplaces

Team marketplaces now support imports of plugin repositories from GitLab, BitBucket, or Azure DevOps so you easily add plugins and distribute them to your team.

Learn more in our docs.