Cursor changelog

Canvases from cloud agents

Cloud agents can now build interactive canvases as part of their work. Share a finished canvas with your team by sending its link.

<figure><video src="https://cursor.com/marketing-static/changelog/cloud-agent-canvases-and-environments.mp4" controls preload="metadata"></video></figure>

Learn more about sharing canvases.

Environments API

The Environments API is now available in beta. Use it to programmatically create and manage the cloud environments your agents run in.

Larger, faster environments

Cloud agent environments now support up to 300 repositories. Large environments also load 5x faster.

Origin now integrates with over 20 apps for deployments, CI, code review, security, monitoring, and project management, from partners including Cloudflare, Linear, Sentry, and Socket Security.

Starting today, the marketplace is also open to public submissions, so any team building developer tools can publish an app for Origin.

Apps for your stack

The marketplace now includes apps for:

• **Deployments:** Cloudflare, Netlify, Render, Spacelift, and Vercel
• **CI:** Buildkite, CircleCI, CloudBees, Depot, EngFlow, Namespace, and RWX
• **Code review:** CodeRabbit, Greptile, and Tenki
• **Security:** Artemis Security, Semgrep, Socket Security, and Upwind
• **Monitoring:** Sentry
• **Project management:** Linear

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/origin-apps-QQ9ZPw6HtXmhbhtleevXGQ5xw1ncs1.png" loading="lazy" alt="Origin App Marketplace listing apps across deployments, CI, code review, security, monitoring, and project management" /><figcaption>Origin App Marketplace listing apps across deployments, CI, code review, security, monitoring, and project management</figcaption></figure>

Publish to Marketplace

To submit an app:

1. Create an app in your namespace. It stays private to your namespace while you build.
2. Build against the Origin API. Apps authenticate with an app JWT and installation access tokens, receive webhook events, and write back check runs, pull request comments, and reviews.
3. Make the app public, then submit it from the app's page with a slug, suggested tags, and a demo video. The video should show install, uninstall, and your core product flows.
4. We review the submission and list the app once it's approved.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/origin-submit-marketplace-XuhYvHQND62RTK4kNpUTDga6SIdPyu.png" loading="lazy" alt="Submitting an app to the Origin App Marketplace" /><figcaption>Submitting an app to the Origin App Marketplace</figcaption></figure>

Get started

Try the apps in the Origin App Marketplace today.

Want to build an Origin app? Start with the publishing guide and the Origin API reference.

The Origin Apps plugin can also answer questions from the live Origin API docs and plan a port to Origin for an app you already run.

You can now see and reply to the local agents running on your computer from the Cursor iOS app.

Get started

Remote Control is on by default for everyone except Enterprise organizations.

Download the Cursor iOS app and sign in. Computers on your account appear in the app automatically. Tap your computer in the app and approve your pairing request in the Cursor desktop app. Your local agents appear in a list. Tap one to see what it's doing or send it a message.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/remote-control-cl-pezewO3SZRrIQxMNaTzdpsP9TD1ChS.png" loading="lazy" alt="Remote Control for local agents in the Cursor iOS app" /><figcaption>Remote Control for local agents in the Cursor iOS app</figcaption></figure>

Agents keep running on your computer

Remote control doesn't move your agents anywhere. It keeps running on your computer, and the app connects to it. Your computer needs to stay on and online for remote control to work.

Keep your computer awake

To stop your computer from sleeping while you're away, turn on "Keep this computer awake" under Remote Control in Cursor's desktop settings. Your computer needs to be plugged in with the lid open.

For Enterprise teams

Remote control is on by default, except for Enterprise organizations. Enterprise admins can turn it on in Org settings > Security and identity > Remote control.

Remote control doesn't require cloud agents to work.

Remote control is available today in the Cursor iOS app.

Today we're launching two Cursor bots for the last mile of shipping code. Rollouts watches every change as it deploys and reports its health per environment. Security Review reports exploitable bugs on every pull request.

Both are available today on Teams and Enterprise plans.

Rollouts

Rollouts attaches a monitor to every pull request and watches the change as it deploys, reporting change health per environment: verified healthy, regression detected, or inconclusive. It's the Cursor version of Firetiger Change Monitors, rebuilt with the Bot Development Kit.

Enable it from the dashboard and connect source control, your deploy system, and your telemetry provider. Rollouts starts watching on the next pull request.

Monitoring plans

When a pull request opens, Rollouts reads the diff and the systems it touches, then writes a monitoring plan as a PR comment. The plan lists the risks it identified, the effect the change is meant to have, the signals it will check, and any gaps in instrumentation that would make the change hard to verify. Edit the plan in the PR and Rollouts uses your version.

Deploy tracking

Rollouts wakes on deploy events for the change's commit and runs the plan against your logs, metrics, and traces. It tracks each environment separately, so a change can be verified in staging and still flagged in production. Rollouts checks the change's intended effect alongside error and latency signals, and reports back on the PR when it reaches a verdict.

Regressions

When Rollouts detects a regression, it names the change it suspects and notifies the author. Depending on configuration, it can also open a revert PR for review or hand the finding to a cloud agent for a fix. Rollouts does not merge or roll back on its own today.

Integrations

Rollouts connects to Origin or GitHub for source control, to your continuous delivery system for deploy events, and to Datadog and other telemetry providers for signals. Feature flag integration is coming soon.

Security Review

Security Review is available today. It reads every pull request in the context of the codebase and posts one review comment reporting exploitable bugs. Style and quality stay with Bugbot.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/security-review-N8azgyLevr8FvNIRqJN6hk71os2Oxu.png" loading="lazy" alt="Security Review comment on a pull request reporting an exploitable bug with a severity and proposed fix" /><figcaption>Security Review comment on a pull request reporting an exploitable bug with a severity and proposed fix</figcaption></figure>

Enable it from the dashboard for the repositories you want reviewed. Draft PRs are skipped.

What it reports

Security Review looks for injection across SQL, command, and template surfaces, along with authentication and authorization bypasses, including checks that a refactor stopped running. It also flags secrets and credentials committed to source, SSRF and unvalidated redirects, unsafe deserialization, and dependency changes that introduce known vulnerabilities. It traces where user input enters and what it passes through.

Findings

Each finding carries a severity, the attack path, and a proposed fix. Dismiss one with a reason and Security Review won't raise it again on that PR.

Team rules

Add rules for your codebase, such as which client external calls must go through or which tables are never queried from a request handler, and Security Review enforces them on every PR.

Get started

Rollouts and Security Reviewer are available today on Teams and Enterprise plans. Enable either bot from the automations tab.

For the next 10 days, we're including usage credits so teams can try Rollouts on real changes. Teams and Enterprise customers receive credits for roughly 50 and 500 changes, respectively.

Today we're launching Projects in Cursor. Projects lets you take on larger bodies of work, such as a feature, a migration, or a full app. It maintains context over months of work, delegates tasks to thousands of subagents, and performs recurring work without being prompted.

Access Projects from the left-hand nav. The coordinator agent in a project doesn't write code itself; it plans the work, delegates it to agents that implement it, and brings the finished work back to you to check. Coordinators create and manage agents on your behalf, running as many in parallel as the work needs.

Powered by Cloud Agents

A Project runs on its own computer in the cloud, so closing your laptop doesn't stop it. When something needs testing on your machine, the coordinator spins up a local agent to run it there.

Shared context

You shouldn't have to onboard an agent every time you start a task. Each Project maintains a set of files that sync across every cloud and local machine its agents use. Agents add research and artifacts, along with what they learn about the codebase and how you prefer work to be done. If one agent figures out how to test a service, for example, every future agent can use those instructions. The shared context grows with the Project, making the coordinator more effective over time.

Subscriptions

Tell the coordinator agent to watch a Slack channel, run on a schedule, or follow all your PRs. This way it can take action based on signals it detects, without waiting for your prompt.

Connect Slack and point it at a bug-report channel, and it starts delegating each time a bug comes in.

Projects are available in beta and rolling out to all users starting today.

Cursor supports **self-hosted machines**, which let you keep tool execution entirely in your own network.

Your codebase, build outputs, and secrets all stay on internal machines running in your infrastructure, while the agent handles tool calls locally.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/uploads/remote-machines-QjJ0ZzGDelSdT7v2CXDdh0BQHqjmH0.png" loading="lazy" alt="Run on menu showing Remote Machines with self-hosted options lambda-test, cloud-demo, and jacks-desktop" /><figcaption>Run on menu showing Remote Machines with self-hosted options lambda-test, cloud-demo, and jacks-desktop</figcaption></figure>

Dynamic pool scheduling

**My Machines** connects a single laptop or VM to your account for personal workflows.

**Team pools** are named queues of workers for a team or enterprise. Capacity can grow as requests arrive and shrink when workers disconnect, so your self-hosted machines can scale with demand. Pools are not tied to one repository: name the pool, and any available worker can claim the request.

Pools can also hibernate idle machines, then restore within a reconnect window when a follow-up arrives, so you don't keep expensive capacity warm just for the next prompt.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/uploads/pools-mNNea8rJyNxaBuz7rSVT2SJOKkRsmv.png" loading="lazy" alt="Cloud Agents dashboard listing Self-hosted Machines pools with active and idle worker counts" /><figcaption>Cloud Agents dashboard listing Self-hosted Machines pools with active and idle worker counts</figcaption></figure>

Run on your sandboxes

Cloud agents can now execute on infrastructure you already use, including from AWS Lambda, Coder, Cloudflare, Daytona, Modal, Namespace, Vercel, and E2B.

Computer use on Linux and Mac

Self-hosted workers now support computer use on Linux and Mac. With the right desktop packages, an agent can click, type, take screenshots, and drive the browser. You can watch its desktop or take control from Cursor.

Cloud Agents no longer require a connected GitHub or other third-party SCM provider to get started. Prompt from the get-go, then save your work to a Cursor Origin repo.

Get started

Select **Start from scratch** in the repo picker, then prompt the agent. In the background, Cursor creates an Origin repo for you.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/start-from-scratch-QflXlxizUwAvBbal0Kst46I0mEZT93.png" loading="lazy" alt="Start from scratch in the repo picker" /><figcaption>Start from scratch in the repo picker</figcaption></figure>

Turn it into a real repo, whenever you want

Once the agent's build is to your liking, click the **Create repo** button to save your work in an Origin repo. Choose a custom name or pick one of the suggested ones, then set the visibility to private or internal. You'll get a fully scaffolded Origin repo, ready to share or keep building on. Navigate to the Codebase tab to find your repo and access your project.

A live preview, right in the browser

Cursor now port-forwards your cloud agent's live environment straight to your browser, so you can preview it and use tools like design mode.

Publish your work

Connect a Vercel account and hit publish to get a live URL for what you built.

A Vercel account is required to use the publish feature.

Get started today.

We're continuing to improve cloud agents and the Cursor harness so always-on agents can operate as a system, building and shipping software on their own without the need for intervention at each loop.

With this release, cloud agents can automatically pick up work in response to events, hold a goal until it's met, and stay on course through long-running sessions.

Subscriptions

Cursor can now monitor your PRs, watch a Slack thread, or run scheduled tasks. Cursor Agent subscribes to an event source (a thread or conversation) and wakes when something happens. Subscriptions are available for cloud agents only, for now.

Cloud agents automatically subscribe to PRs they create and drive them to completion, fixing CI and addressing bot comments. In Slack, ask `@cursor check back in an hour and keep going until that feedback is in`.

<figure><video src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/2026-08-13-changelog-subscriptions-ObbzEOzAUiaMhh70DUYG6fJZwv2SQ8.mov" controls preload="metadata" loop></video></figure>

Custom modes

Use any skill as a Custom Mode: a skill that stays pinned in the chat. Custom modes keep agents focused on a skill - you can think about it like "always on" skills.

From `/`, pick a skill and press ⌥⏎ (Mac) or Alt+Enter (Windows), or choose **Use as Mode**.

<figure><video src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/2026-08-13-changelog-sticky-skills-GyjHI2f0MGVFngQBebLBnlQjEkkxQm.mp4" controls preload="metadata" loop></video></figure>

Subagents on their own machines

Subagents can now run on their own virtual machines. Each gets an isolated copy of the project with clean context in its own cloud environment.

Have subagents test the parent agent's changes in fresh environments or swarm independent fixes without collisions. Try `run a swarm of subagents to test my app for bugs, each in its own environment`.

<figure><video src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/2026-08-13-changelog-subagents-YD3SIKspySs8zoib2kY7RAPA9Injca.mp4" controls preload="metadata" loop></video></figure>

/goal

Use `/goal` to give the agent a long-lived objective to work towards until it's fully complete.

Try `/goal fix all flaky tests and make CI green` in a new chat. Pair it with a custom mode to follow a playbook, or `/loop` for recurring check-ins.

<figure><video src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/2026-08-13-changelog-goal-CPDEcewlxhbdqRa131C8yZjhDdOGzb.mp4" controls preload="metadata" loop></video></figure>

Steering improvements

You can now send a message to steer the agent while it's working without interruption. Follow-ups wait for the next tool call instead of cutting the agent off mid-action.

Type a follow-up and hit Send now, or press ⏎ twice.

Cursor can now host your code.

Origin begins rolling out today in early beta on all paid plans. We're starting with the essentials, designed for agent scale: repos, pull requests, code browsing, and GitHub sync. Agent-native features ship soon.

Origin Repos

The new **Codebase** tab is home for Origin repos.

Click **+New** to create a new repo and name it. Once you do, a page shows you how to install the CLI, with commands for how to clone a repo or push a local project. Push, and your code is hosted on Origin.

For Origin-hosted repos, Origin is the source of truth. Pushes land on Origin, and GitHub is not in the path.

Name your codebase when you create your first repo. That name becomes part of every repo's URL: cursor.com/codebase/`acme-corp`.

Bring your GitHub repos

Your GitHub repos can sit alongside the ones Cursor hosts. Connect GitHub to Cursor, pick your org, and you'll see the repos you can sync. Select one and Cursor pulls it in. You choose what gets synced and can disconnect a repo at any time. Anyone with read or write access to a synced repo can view it in Cursor too.

Synced repos update in real time. Browse, search, and pull from the copy in Origin. For synced repos, GitHub stays the source of truth: pushes keep going to GitHub, and Origin mirrors the result. Icons next to each repo name tell you which ones Cursor hosts and which came from GitHub.

Pull requests

Every repo has pull requests. Open one to see the timeline, commits, checks, and files changed. Review the diff, leave comments, and merge.

Pull requests on synced repos sync both ways: comment in Cursor and it posts to GitHub, react or reply on GitHub and it shows up in Cursor within seconds. Got a review assigned to you on GitHub? Review and merge it from Cursor.

Agents in every repo

Your code, PRs, and agents are now in the same place. Ask Cursor questions about code you're browsing. It can answer, make changes, update PRs, or push a branch.

App extensions for Cursor repos

We're building an app ecosystem so your whole stack works seamlessly with Origin. Integrations with Vercel, Depot, and Buildkite are already available, with more coming soon.

Connect Vercel from a repo's **Apps** tab and every PR gets a preview deployment where you can test and make comments. Merge, and it ships to production. For CI, connect Depot or Buildkite. Both run your existing GitHub Actions workflows and Buildkite also runs its native pipelines.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/origin-apps-VXN2qUBlVUoZVFkdDCeojn1GkN4IIb.png" loading="lazy" alt="Vercel, Depot, and Buildkite apps connected to an Origin repo" /><figcaption>Vercel, Depot, and Buildkite apps connected to an Origin repo</figcaption></figure>

Settings

Every repo has settings. Check sync status for GitHub repos, manage who has access, and see which apps are connected.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/origin-settings-tipE1aGfr5qnTYJlRVBbwYwqsxfCSC.png" loading="lazy" alt="Origin repo settings showing sync status, access, and connected apps" /><figcaption>Origin repo settings showing sync status, access, and connected apps</figcaption></figure>

Origin is rolling out in early beta to all paid plan users starting today, except enterprise orgs whose admins opt out. Name your codebase and create your first repo.

Learn more in our docs or get started today.

Agents do their best work when they start in a ready environment: repos cloned, dependencies installed, and your install script already run.

This release introduces **builds**: ready-to-use copies of your development environment that Cursor prepares in the background. Agents boot into a ready environment instead of setting up from scratch each session. Builds are included with Cloud Agents at no additional cost.

Faster starts

Cursor runs a new build of your environment regularly. When a build succeeds, it becomes the environment future agents start from. Cursor keeps warm copies ready so the next agent does not wait. Internally, our environments now boot 10x faster, with 3x faster time to first token.

Use your install command for anything that can be prepared ahead of time. The start command still runs when you first prompt an agent and should focus on services that need to be fresh in the session.

More resilient agent runs

When a bad commit or dependency update breaks your environment, agents keep using the last successful build. The broken build never becomes active, you are notified of the issue, and your agents keep working while you debug in the background.

Build history and debugging

Each environment has a **Builds** tab in the Cloud Agents dashboard. You can inspect build status, logs, commit SHAs, and which build each agent run used. Agents can also inspect and manage builds using built-in tools.

Getting started

New environments use Builds automatically. For an existing environment, open it in the Cloud Agents dashboard, go to the **Builds** tab, and click **Enable Builds**. Or click **Run setup agent** first to test the migration and review any proposed config changes.

You can also trigger a Build manually, debug a failing Build with an agent, and control how stale Builds refresh with a configurable threshold.

Learn more in our announcement post and 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.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/inbox-43-WUi5D4anOQABnh7gqHuJgCky6upWm6.png" loading="lazy" alt="Inbox on Cursor for iPad" /><figcaption>Inbox on Cursor for iPad</figcaption></figure>

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 and Composer, 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.

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.

Improvements

• Per-request classification by task type and complexity
• Optimization modes: Cost, Balance, and Intelligence
• Admin controls: per-team and per-group enablement, mode restrictions, default mode, and model allow and block lists
• Routed model can be displayed or hidden (hidden by default)
• Soft and hard enforcement options for standardizing on Auto
• Grok 4.5 required as a price-efficient routing option

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.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/redesigned-picker.png" loading="lazy" alt="Redesigned project and repo pickers" /><figcaption>Redesigned project and repo pickers</figcaption></figure>

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.

Picker Improvements

• Improved repo picker grouping with options under No Repo, On This Computer, and Cloud.
• Added the "Run on" picker that shows where your agent can run (Cloud, This Computer, or Remote Machines) and drills into the relevant choices (environments, local options, and so on) from there.
• The branch picker opens on your default branch and recently used branches instead of a long flat list, with search for everything else.
• Removed the Home concept so working without a repo is an explicit No Repo choice.
• Combined all remote options—your machines, team pools, and existing remote workspaces—into one searchable Remote Machines menu.
• Multi-repo and multi-root selection is a Select Multiple toggle inside the Cloud and This Computer flyouts, replacing the separate Set Up Workspace builder.
• Moved search to the top of the menu.
• Simplified the footer.
• Added the ability to find the No Repo option by typing `none` or `no repo`.
• If a repo exists only in the cloud, the picker suggests cloning it locally.
• Added clearer section dividers.
• Added folder icons with a small cloud badge for cloud repos.
• Removed redundant `Current` tag in the branch list.

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

Team MCPs in team marketplaces

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 -> Plugins & MCPs**. 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.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/team-mcps.png" loading="lazy" alt="Team MCP servers" /><figcaption>Team MCP servers</figcaption></figure>

Marketplace access by organization group

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

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/marketplace-orgs.png" loading="lazy" alt="Marketplace organization groups" /><figcaption>Marketplace organization groups</figcaption></figure>

Under **Dashboard -> Plugins & MCPs -> 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 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 in the Agents Window to take an agent you're running on your computer and keep directing it from your phone.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/remote-control.png" loading="lazy" alt="Remote Control" /><figcaption>Remote Control</figcaption></figure>

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 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.

Cursor Automations save you time by automating repetitive tasks with always-on agents. This release introduces the **/automate** skill, new triggers for GitHub and Slack, and support for computer use.

/automate skill

Use **/automate** to create an automation directly in your local agent session.

Describe the task you want to automate in plain language and Cursor will configure the triggers, instructions, and tools for you.

An emoji trigger for Slack

React to any Slack message with a designated emoji to kick off an automation. At Cursor, we use this to trigger specific automations right from Slack.

New GitHub triggers

Automations now support five additional GitHub triggers:

• **Issue comment:** when a comment is made on a non-PR issue
• **PR review comment:** when an inline comment is left on a pull request diff
• **PR review submitted:** when a PR review is submitted
• **Review thread updated:** when a review thread on a pull request is marked resolved or unresolved
• **Workflow run completed:** when a GitHub Actions workflow run finishes on a pull request or branch

We've added new templates for triaging failed GitHub actions and auto-fixing PR review comments to the Cursor Marketplace to help you get started.

Computer use tool for automations

Cloud agents kicked off by automations can now use their own computers to produce demos or artifacts of their work.

The computer use tool is enabled by default for every automation, just tell the agent to include a demo of its work in your instructions.

To get started, update to the latest version of Cursor. Learn more in our docs.

Improvements (3)

• Automations can now be saved in an incomplete state, so you can navigate away to set up an MCP auth without losing your progress
• Automations can now open PRs by default; so you no longer have to specify that tool in the UI
• You can now delete memory files in the UI, or prompt your automation to delete outdated memories when it runs

This release introduces updates to cloud agents in the Agents Window of the Cursor desktop app.

Cloud environment setup

Cursor can now help you set up your dev environment in the cloud in less than 10 minutes. You can watch the agent's progress in a shared terminal session as it handles setup tasks like installing dependencies.

Your environment is captured in a reusable snapshot, so future cloud agents start up faster with the ability to test changes by running your software. It can iterate over long time horizons until outputs are verified. This benefits your entire team when committed to `.cursor/environment.json`.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/cloud-environment-setup.png" loading="lazy" alt="Cloud environment setup" /><figcaption>Cloud environment setup</figcaption></figure>

Cloud subagents with /in-cloud

Use `/in-cloud` to spin up a cloud subagent in its own VM to work on the next task you submit. It runs on its own VM and branch, so your local workspace stays clean and responsive.

This is especially useful for isolating long-running or parallel work like fixing CI, investigating an issue, or exploring a codebase while you keep working locally.

You can also ask a cloud subagent to babysit a PR by clicking on the quick-action pill or using `/babysit`. The cloud agent will iterate remotely to prepare your PR for merge without tying up the local session.

The cloud subagent can run in the background without interrupting the parent agent, which can continue to run locally or in the cloud.

Handoff between local and cloud

Move agent sessions more reliably between your local computer and the cloud. You can offload long-running work from your machine and run as many cloud agents in parallel as you want. Pull a cloud agent back down to local to test changes yourself.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/handoff-to-cloud.png" loading="lazy" alt="Handoff between local and cloud" /><figcaption>Handoff between local and cloud</figcaption></figure>

The average review time for Bugbot is now ~90 seconds, down from ~5 minutes. Bugbot also finds 10% more bugs per review on average — 0.62, up from 0.56 — and costs ~22% less per run.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/bugbot-performance.png" loading="lazy" alt="Bugbot is now over 3x faster, 22% cheaper, and finds 10% more bugs per review." /><figcaption>Bugbot is now over 3x faster, 22% cheaper, and finds 10% more bugs per review.</figcaption></figure>

These performance gains are made possible by progress we've made training Composer 2.5, which now powers Bugbot. Bugbot respects model block lists, and speed and performance can vary depending on your configuration.

Run Bugbot before you push

You can now run Bugbot and Security Review with `/review` before pushing code. `/review` prompts you to choose which agents to run, or use `/review-bugbot` and `/review-security` directly.

`/review` also syncs with Bugbot on GitHub and GitLab. If you run `/review` and then open a PR with the same diff, Bugbot recognizes it, skips the review, and leaves a comment noting it has already reviewed that diff.

Available in Cursor 3.7+ and on cursor.com/agents, with support in CLI coming soon.

Only review what's new in your PR

You can now configure Bugbot to only review what's new since the last review, keeping feedback focused on your latest updates.

Learn more in our docs.

With Design Mode in the Cursor browser, you can click, draw, or describe changes by voice to help agents update your UI.

Multi-select elements

Click on two or more elements together in the browser. Cursor sees the selected elements, their code, the surrounding layout, and the visual relationships on the page.

Ask the agent to make one match the other, remove repeated content, or adjust a group of components at once.

Voice input

Narrate changes through the Design Mode overlay. The mic stays available while an agent is mid-run, so you can queue the next change by voice without waiting for the previous one to finish.

We've shipped a batch of new functionality across the TypeScript and Python SDKs. You can now choose how agent and run metadata is persisted, expose your own functions to the agent as tools, route local tool calls through auto-review, and nest subagents to any depth. This release also brings a set of reliability, performance, and platform fixes that make local and cloud SDK agents easier to run in production scripts, CI, and custom integrations.

Custom tools

You can now hand the local agent your own tools by passing function definitions through `local.customTools`, on `Agent.create()` or per `send()`. The SDK exposes them to the agent through a built-in MCP server called `custom-user-tools`, so the model calls your code through the same path and the same permission gate as any other MCP tool.

Before this, exposing a custom capability meant standing up your own stdio or remote HTTP MCP server and wiring it into the agent. Now a function definition is enough. Custom tools are also visible to every subagent of a parent agent, so a tool you define once is available throughout the whole run.

Auto-review

By default, a local SDK agent runs tool calls without asking for approval, since there's no human in the loop in a headless run. Set `local.autoReview` to route those calls through auto-review instead. A classifier decides which calls run automatically and which to hold back, rather than bypassing review entirely.

You steer that classifier with natural-language instructions in `permissions.json`. The `autoRun.allow_instructions` field describes call shapes to lean toward allowing, and `autoRun.block_instructions` describes the ones to hold for review. For example, you can allow read-only inspections of build artifacts while always pausing on destructive operations like deletes.

```jsonc { "autoRun": { "allow_instructions": [ "Read-only inspections of build artifacts under ./dist are fine." ], "block_instructions": [ "Always pause delete operations so I get a chance to review them." ] } } ```

JSONL and custom stores

Both SDKs persist agent and run metadata so you can resume an agent after a process restart. Until now, that store was SQLite. You can now opt into a JSONL store instead, which writes a plain, append-only file you can read, diff, and check into version control. Both `SqliteLocalAgentStore` and `JsonlLocalAgentStore` are exported directly.

If neither default fits your setup, implement the public `LocalAgentStore` interface and pass it through `local.store`. Build an in-memory store for ephemeral CI runs, or back persistence with Postgres when you want agent state to live next to the rest of your application data. The Python SDK exposes host, JSONL, and composed JSONL stores through the bridge.

Nested subagents

Subagents can now spawn their own subagents, and so on. A reviewer subagent can delegate to a test-writer, which can delegate further, with each level keeping its own prompt and model. There's nothing to turn on; a subagent session registers the executor it needs to call `Task`, so nesting works automatically for any agent that defines subagents.

Reliability, performance, and platform improvements

This release also includes a batch of quality-of-life fixes across both SDKs.

Reliability

• **Run correlation**: Every `send()` now carries a platform-generated `requestId`, exposed on `Run` and `RunResult` and persisted across the in-memory, SQLite, and JSONL stores. Tie a script or CI run to backend logs, analytics, and support threads without inferring it from `agentId`.
• **Reliable `wait()` on local runs**: Local runs no longer resolve `wait()` before the terminal result is written. Hydration keeps refreshing until the run reaches a final state, so automation reads a complete result.
• **Safe checkpoints on dispose**: Disposing a local agent no longer removes checkpoint data when a root reference is missing but checkpoint blobs still exist. The agent directory is only cleared when there's genuinely nothing left to keep.
• **Cloud streaming over HTTP/1.1**: Cloud agent sessions now stream correctly on HTTP/1.1 transports used by some proxies, older Node fetch stacks, and certain CI images. HTTP/2 behavior is unchanged.

Performance and packaging

• **Lighter import**: Importing `@cursor/sdk` no longer eagerly loads the full local agent stack. Cloud-only and type-only consumers skip the local runtime cost until the first local call, with no API change. The first local call pays a one-time import, then stays cached.
• **Self-contained TypeScript types**: Published `.d.ts` files no longer reference unpublished workspace packages. This fixes `TS2305` and `TS2307` errors under `skipLibCheck: false` and silent `any` on stream types like `TurnEndedUpdate`.
• **Bundled ripgrep**: Local shell runs use the bundled platform `rg` binary without modifying your global `PATH`. On Windows, prepending ripgrep no longer clobbers the `Path` variable.

Models

• **Composer 2 routes to Composer 2.5**: SDK clients still pinning retired `composer-2` slugs are routed to Composer 2.5 automatically, keeping fast variants intact, so older scripts keep running.

Python SDK

• **Workspace-scoped `list_runs`**: `Client`, `AsyncClient`, and `Agent.list_runs` take an optional `cwd`, and the bridge falls back to its launch workspace. This fixes spurious "agent not found" results when the bridge runs as a subprocess.
• **Clearer not-found errors**: Looking up an agent that isn't in the resolved workspace returns a clear not-found error instead of an opaque internal error.
• **0.1.6 release and analytics**: `cursor-sdk` 0.1.6 documents the Buildkite release path and labels SDK usage as `sdk-python-` for clearer analytics.

Run `npm install @cursor/sdk` or `pip install cursor-sdk` to upgrade. Scripts pinning `composer-2` move to Composer 2.5 automatically, and `requestId` is a safe addition to your run metadata schema. See the TypeScript and Python docs for full details.

With canvases, agents can create interactive artifacts like dashboards, reports, and internal tools that you can share with your team.

This release introduces Design Mode for faster canvas editing, new ways to understand context usage, and other quality-of-life improvements.

Design Mode in canvases

Design Mode is now available in canvases.

Select and annotate UI elements directly in a canvas to guide Cursor's edits, just as you would in the browser. Instead of describing the change in text, you can point to it, provide feedback, and iterate more quickly.

Context usage report in canvas

Cursor can now show your agent's context usage as an interactive report in a canvas.

The context explorer breaks down where tokens go across the system prompt, tool definitions, rules, skills, and more. Because it's a canvas, you can ask the agent follow-up questions, and it can customize the report to answer your specific questions.

Click the Debug with Agent button embedded in the canvas to ask Cursor to identify opportunities to reduce context usage in a new conversation.

Canvas Improvements (4)

• Shared canvases can now be opened full-screen in the browser, making them easier to present to others.
• Added the ability for agents to embed buttons in canvases that will run a specific prompt when clicked.
• Improved the agent's ability to fix canvas type errors.
• Improved component styling, and added more chart customization functionality.

Enterprise customers can now manage multiple Cursor teams from one place, with different security, governance, budget, and feature controls for each. These capabilities are now generally available to all Enterprise customers.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/blog/ent-org-arch-4-light.png" loading="lazy" alt="Cursor Enterprise organization architecture with organizations, teams, and groups" /><figcaption>Cursor Enterprise organization architecture with organizations, teams, and groups</figcaption></figure>

Organizations

An organization is the top-level container for your company's identity, administration, and membership. It gives admins one place to view and manage their entire Cursor setup, including a rollup of spend and token usage across every team.

Teams

Teams are the operating unit for a department, region, or subsidiary. This is what admins manage as their Cursor org today. We've moved that unit under an organization, so you can run multiple teams, each with its own security, governance, spend, and feature settings.

A user can belong to more than one team, with a different role in each. For current customers, your existing team is preserved and becomes the default home for login, routing, and creating new teams.

Groups

Groups are a lightweight collection of users that can sit across or within teams. They give cohorts of users separate model access, spend limits, and agent permissions without standing up a whole new team. When a user belongs to more than one team or group, the most permissive setting wins.

Learn more in our announcement post or docs.

Improvements (5)

• Multi-team support so users can be on multiple teams at once
• Organization-level IDP management
• Organization-level usage analytics, with drill downs to each team
• Admins can move users between teams through the dashboard, API, or CSV
• New users joining a team inherit settings and permissions automatically

Auto-review is a new run mode that allows Cursor to work for longer with fewer approval prompts and safer execution.

Auto-review applies to Shell, MCP, and Fetch tool calls. Allowlisted calls run immediately, and calls that can be sandboxed run in the sandbox. All other agent actions go to a classifier subagent that decides whether to allow the call, try a different approach, or ask for your approval.

Configure your run mode in **Settings > Cursor Settings > Agents > Approvals & Execution**. You can also steer the classifier agent by giving it custom instructions.

Learn more in our docs.

Shared canvases

You can now share canvases from Cursor with your teammates.

Canvases are interactive artifacts created by agents, like reports, dashboards, and custom interfaces. Instead of sharing a full chat thread, you can share a link to a live snapshot of a canvas for teammates to open in the browser.

Teammates open a shared canvas from its link with read-only access. The Shared Canvases page in the Cursor Dashboard lists the canvases you've published, so you can manage your own shares. Shared canvases are available on Pro, Teams, and Enterprise plans.

Learn more in our docs.

/loop skill

With /loop, Cursor can run a prompt repeatedly on a local schedule, until a certain outcome is achieved, or until you stop it. If you don't specify a fixed interval, the agent decides when or what event should wake it.

Use the /loop skill for local long-running agents. For example, you can ask it to “check deploy status every 5 minutes” or “work on this feature until tests pass.”

This release brings Cursor Automations to the Agents Window and introduces the ability to configure automations with multiple attached repos or no repos at all.

For the next 7 days, all agent runs for newly created automations are 50% off.

Automations in the Agents Window

Cursor Automations are now available in the Agents Window, in addition to cursor.com/automations. Create and manage your automations in the same workspace as your agents.

Multi-repo automations

A lot of engineering work spans more than one codebase. You can now attach multiple repos to an automation so agents reason across all required context and work across repos to deliver, test, and verify tasks.

No-repo automations

Many useful automations exist apart from code, where agents monitor your tools and act on key signals. You can now create automations without an attached repository.

We've added five new templates for no-repo automations to the Cursor Marketplace to help you get started:

• **Slack digest agent**: Summarizes unread DMs and key Slack channels every morning and prioritizes them by importance
• **Product analytics agent**: Delivers a weekly digest of key metrics from your data warehouse like Databricks
• **Product FAQ agent**: Watches a Slack channel for questions and writes a first response based on docs, codebase context, and past threads
• **Product finance agent**: Pulls financial data from a billing provider like Stripe for recurring revenue reports
• **Customer health agent**: Monitors key systems like Granola, Slack, and Databricks and flags accounts where health signals are shifting

Read our docs to learn more.

Cursor is now available in Jira.

Assign work items to Cursor, or mention `@Cursor` in a comment to kick off a cloud agent. Cursor uses the work item title, description, comments, and your team's repository settings to scope the task.

You can ask Cursor to fix bugs, add features, update tests, or investigate something described in the ticket. When the agent finishes, Jira shows completion updates and includes a link to the pull request.

Install the integration from Cursor integrations. You need Cursor admin access and Jira Commercial Cloud with Rovo enabled. Learn more in our docs.

Composer 2.5 is now available in Cursor.

It's a substantial improvement in intelligence and behavior over Composer 2. It is better at sustained work on long-running tasks, follows complex instructions more reliably, and is more pleasant to collaborate with.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/blog/composer-2.5-benchmark-table-landscape-light04.png" loading="lazy" alt="Composer 2.5 benchmark results" /><figcaption>Composer 2.5 benchmark results</figcaption></figure>

• **Standard:** \$0.50/M input, \$2.50/M output tokens
• **Fast** (default): \$3.00/M input, \$15.00/M output tokens

Composer 2.5 includes double usage for the first week. See our model docs for full details.

Read more in our announcement.

This release introduces quality-of-life improvements to the Agents Window.

Full-screen tabs

Full screen maximizes the right panel so you can focus on a single tab.

Files, changes, canvases, PRs, browsers, and terminals can expand to fill the entire working area. This replaces the agent chat with a floating prompt bar.

Enter and exit full screen by clicking on the expand/contract button in the panel header, using the command palette, or pressing `Cmd/Ctrl+Shift+M`.

Compact chat responses

Compact chats give you a tighter view of your agent conversations so you can read threads more quickly without losing important context.

Customize tool call density to control how much of the agent's tool activity is shown in each response:

• Compact: shows concise results with minimal tool traces
• Balanced: includes important intermediate steps
• Detailed: provides near-complete step-by-step context

Improvements (8)

• Improved PR tabs by adding clearer review states, better reviewer/thread visibility, and more predictable PR tab actions.
• Improved long-chat scrolling to make it smoother, added better undo grouping in prompt input, and improved behavior while streaming.
• Added clearer status text for background/resumed tasks.
• Added cleaner environment/repo selection and better persistence when switching contexts.
• Improved MCP auth token lifecycle handling.
• Removed noisy in-app terminal notifications and improved shortcut behavior.
• Clarified model naming and selection behavior in the model picker and added stronger fallback handling.
• Improved search and navigation to make it faster and more reliable in large workspaces.

Bug Fixes (9)

• Fixed PR tab bugs affecting branch lookup, header state, and diff loading.
• Fixed background task reliability issues like resume failures, interrupt edge cases, and incorrect status scoping on resumed subagents.
• Fixed cloud agents bugs blocking setup, state merge/persistence bugs, and multi-repo identity issues.
• Fixed MCP/OAuth reliability bugs like transient 401/stale-token cases and large-token handling edge cases.
• Fixed edge cases around slash menu + approval regressions, ask-question flow issues, and paste-chunk handling.
• Fixed keyboard shortcuts bugs in modals, vim/emacs caret style leakage, and other key handling.
• Fixed hook invocation/path-length issues and Git prompt-related regressions.
• Fixed model-routing mismatches, proxy body normalization, and thought-chunk forwarding issues.
• Fixed webhook auth/hostname resolution, GHES installation persistence, and mirrored-repo behavior.

To take engineering tasks from start to finish, agents need a development environment similar to the setup on your laptop: cloned repositories, installed dependencies, credentials for internal toolchains, and access to build systems.

This release introduces new tools for teams to configure development environments for their agents. Cursor also can use these tools to set up and maintain environments for you. Together, this makes it easier for teams to run fleets of parallelized agents that handle tasks from end-to-end, inside development environments you fully control.

Multi-repo environments

Cloud agents and automations now support multi-repo environments, building off our work on multi-root workspaces. You can configure a single environment with all the repositories an agent needs for its work, with re-use across sessions.

Environment configuration as code

To make it easier to change, debug, and review environment definitions, we have improved Dockerfile-based configuration.

This includes support for build secrets, making it easy to securely access private package registries directly from your Dockerfiles. Build secrets are scoped to the build step and aren't passed to the running agent's environment.

We've also upgraded layer caching, so that only the updated layers of your image rebuild when you change the Dockerfile. Builds that hit the cache run 70% faster.

Improved agent-led environment setup

As Cursor configures your environment, it will ask you questions, flag missing credentials, and validate that your environment is set up properly.

Cursor will always show you the version of the environment your agent is running in. If your environment configuration fails, it will default to a base image with clear warning signs so that your cloud agents can keep running instead of immediately failing.

Environment governance and security controls

Every development environment now has its own version history that users can review and roll back. Admins can also restrict rollback permissions to admins only. An audit log captures every action team members take on environments, giving security teams full visibility into who changed what.

Egress and secrets can now be scoped at the development environment level. Secrets configured for one environment aren't accessible from any other.

Learn more about agent development environments in our announcement and docs.

Cursor is now available in Microsoft Teams.

Mention @Cursor in any Teams channel to delegate a task to a cloud agent or pull information from Cursor into Teams.

Cursor automatically picks the right repository and model based on your prompt and recent agent activity. It reads the entire thread for context before implementing a solution and creating a PR for your team to review.

Get started by installing the integration in the Cursor dashboard. Learn more in our docs.

Teams admins and Individual plan users can now customize the effort level Bugbot uses for its PR reviews, with three different configurations:

• **Default:** Bugbot continues to use the same effort level as it does today. Optimized for efficiency and speed.
• **High:** Bugbot spends more time reasoning. Reviews are more expensive and take longer, but Bugbot may find more bugs.
• **Custom:** Describe in natural language when Bugbot should use default or high effort. Cursor will dynamically set effort levels based on your instructions.

Customers must be on usage-based billing for Bugbot to customize effort levels. Learn more in our docs and go to your Bugbot dashboard to get started.

Bugbot improvements

• With default effort, Bugbot finds 0.7 bugs per run, on average. Over 79% of these bugs are resolved by users at merge time.
• With high effort, Bugbot finds 0.95 bugs per run, on average.

This release introduces a new PR review experience, faster execution on plans through parallel agents, and new quick-action pills for common workflows.

PR review

A new PR review experience is now available in Cursor 3. Take PRs from creation to merge all in one place.

• The Reviews tab now shows inline review threads and top-level PR comments.
• The Commits tab gives you a focused view of commit history for the PR.
• The Changes tab makes it easier to navigate larger PRs with a file tree and changes picker.

You can see useful context like reviewer status and pending review banners, and quick action pills allow you to take next steps faster.

Build in parallel from plans

Cursor can now execute on plans faster by multitasking across tasks instead of tackling them one at a time.

Click "Build in Parallel" to have it identify independent parts of your plan and run them simultaneously using async subagents. Cursor will keep dependent steps in order when needed.

Split changes into PRs

When multitasking in Cursor, you can now use a built-in quick action to split changes into PRs.

It will use chat context to identify logical slices, default to independent PRs unless dependencies are required, create a backup snapshot, and propose a split plan for your approval.

Pin skills as quick actions

You can now pin your most commonly used skills as quick-action pills for faster access.

Improvements (6)

• Added the ability to control Explore subagent behavior from settings: choose a specific model for Explore subagents to run on, inherit the same model as the parent agent, or disable Explore subagents altogether.
• Added support for general model names for subagent configuration (i.e., set `model: opus` to have subagents always use the newest Opus model).
• `/multitask` is now available in the editor for running async subagents to parallelize your requests instead of adding them to the queue.
• Improved prompt input undo grouping, so undo/redo feels more natural during edits.
• Improved long-chat handling and reduced jumpiness and other surprising behaviors.
• Made MCP connection behavior more predictable, and added explicit stale token cleanup on re-auth.

Bug Fixes (5)

• Fixed terminal interaction bugs in the agents window, including editing shortcut issues and approval/overlay edge cases.
• Fixed several slash menu and input-approval regressions.
• Fixed MCP auth edge cases, including transient 401 handling and stale credential behavior.
• Fixed multi-repo environment selection and cache issues.
• Fixed various cloud agent timing and hydration edge cases that could degrade reliability.

You can now see a breakdown of your agent's context usage.

Use these stats to diagnose context issues and improve your setup across rules, skills, MCPs, and subagents.

This release introduces updates for Enterprise admins: a new system for model controls, updated spend management, and more detail for usage analytics.

Model access controls

Admins can now set more granular allow or blocklists at the model and provider level. You can block entire providers or specific model configurations for speed and context window size.

Enterprises also have the option to block new providers or model versions by default.

Customers with existing blocklists will need to migrate to the new system by June 1st. Admins should go to their team model settings in the Cursor dashboard to get started.

<figure><video src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/cpp_videos/model-blocklist-final.mp4" controls preload="metadata" loop></video></figure>

Soft spend limits and intelligent alerts

Admins can now set soft limits instead of hard limits to avoid blocking users. Cursor can also monitor usage and sends automatic alerts to users reaching 50%, 80%, and 100% of their soft or hard limits.

This keeps users productive while giving admins and users visibility into consumption patterns.

Go to the spend management settings in the Cursor dashboard to get started.

<figure><video src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/cpp_videos/spend-alerts.mp4" controls preload="metadata" loop></video></figure>

Updated usage analytics tab

Admins can now filter usage by specific users, or break it down by product surface: clients, Cloud Agents, automations, Bugbot, and Security Review.

Go to the usage analytics tab in the Cursor dashboard to get started.

<figure><video src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/cpp_videos/usage-analytics.mp4" controls preload="metadata" loop></video></figure>

Admins can now create a team marketplace without connecting a repository first. Add, remove, and configure install behavior for first-party plugins directly in team marketplace settings.

Plugins bundle capabilities like MCP servers, skills, subagents, rules, and hooks that extend agents with custom functionality. Each plugin can be distributed in one of three ways:

1. Default Off: users can discover and opt in
2. Default On: users get the plugin installed by default, but can opt out
3. Required: users always have the plugin and cannot uninstall it

Get started in the Cursor dashboard.

Cursor Security Review is now in beta on Teams and Enterprise plans. You can run two types of always-on security agents: Security Reviewer and Vulnerability Scanner.

Security Reviewer

Security Reviewer checks every PR for security vulnerabilities, auth regressions, privacy and data-handling risks, agent tool auto-approvals, and prompt injection attacks. It will leave inline comments at the exact diff location with severity and remediation.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/security-reviewer.png" loading="lazy" alt="Security Reviewer leaving inline comments on a pull request diff." /><figcaption>Security Reviewer leaving inline comments on a pull request diff.</figcaption></figure>

Vulnerability Scanner

Vulnerability Scanner runs scheduled scans of your codebase to check for known vulnerabilities, outdated dependencies, and configuration issues. You can configure it to send updates of its findings in Slack.

<figure><img src="https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/vuln-scanner.png" loading="lazy" alt="Vulnerability Scanner findings and scheduled scans in Cursor." /><figcaption>Vulnerability Scanner findings and scheduled scans in Cursor.</figcaption></figure>

---

Customize Cursor-managed security agents by adjusting triggers, adding your own instructions, giving them custom tooling, and choosing how outputs are shared. For example, you can plug in MCP servers for your existing SAST, SCA, and secrets scanners for Cursor to use as part of the review.

We're also continuously improving the runtime, harness, and models powering Cursor Security Review for a strong out-of-the-box experience.

Security agents draw from your existing usage pool. Admins can enable Security Review in the Cursor dashboard to get started.