Cursor Release Notes
144 release notes curated from 149 sources by the Releasebot Team. Last updated: Nov 7, 2026
- Nov 6, 2026
- Date parsed from source:Nov 6, 2026
- First seen by Releasebot:Nov 7, 2026
Voice Chat with Agents
Cursor adds realtime voice calls with AI agents across the Agents Window, IDE, web, and iOS. Users can talk through changes, check progress, and hear spoken updates while agents work, with voice options powered by Grok Voice.
You can now talk with your agents in a realtime voice call. Describe a change out loud, ask what an agent is working on, and hear updates as the work moves forward.
Voice chat works in the Agents Window, the IDE, on web, and in Cursor for iOS.
Start a call
When the agent is idle and the chat input is empty, click the waveform button labeled Start voice chat. It sits where Send usually is, next to the microphone button for dictation.
On iOS, you can also say "Hey Siri, call Cursor" to start a call with a new agent, and mute or hang up from the Lock Screen with a Live Activity.
Talk while the agent works
The voice agent listens, replies, and hands coding work to the agent in your chat. While that agent runs, you can keep the conversation going. Ask what changed in a diff, check on a run, search earlier messages and calls with this agent, or switch between workers in a Project that has them.
The coding agent speaks for itself too. It shares short progress notes while it works and a brief answer when it's done, so you usually hear a short update instead of the full written reply.
Powered by Grok Voice
Voice chat runs on Grok Voice. Pick from many voices in Voice settings, including Ara, Eve, Leo, Rex, and Sal. With Privacy Mode on, voice chat runs with zero data retention.
Voice chat and dictation
Voice chat is separate from dictation, which earlier releases called Voice Mode. Dictation still turns your speech into text in the chat input, and Cmd+Shift+Space still toggles it in the IDE. Voice chat is a two-way conversation where the agent answers out loud.
Update Cursor to try voice chat. Learn more in our docs.
Original source - Nov 5, 2026
- Date parsed from source:Nov 5, 2026
- First seen by Releasebot:Nov 5, 2026
Build Live Apps in Cursor
Cursor now lets teams build and deploy live apps with databases and authentication, then share them securely with teammates. Built-in security checks and admin controls help keep published apps protected, and the capability is available on paid plans with cloud agents.
Agents have lowered the cost of writing code, but most apps and tools that users build never make it off of localhost.
Now, you can build live apps directly in Cursor and share them with a link. Describe what you want to create and Cursor will handle the rest: build the app, set up a database, configure auth, and deploy it.
With this release, anyone in your org can now build useful tools for their work and share them with teammates. Update Cursor to try it out.
How it works
To get started, kick off a cloud agent and tell it explicitly that you want to build an app.
Cursor will scaffold the web app, spin up a Postgres database if needed, set up authentication behind Cursor SSO, and provision hosting. If the app needs to connect to your systems, like a data warehouse, Cursor will ask for the secrets it needs.
When you go to publish your app, you pick a unique domain and Cursor gets you back a live link.
At Cursor, users across sales, operations, legal, finance, and engineering are building internal apps. Some of the most useful ones are:
- Internal ops tools for event registration, account assignments, and desk seating
- Multimedia presentations for customers that combine slides, videos, and interactive demos
- Training, enablement, and onboarding experiences for new hires
- Live dashboards and tools for sales teams to understand their pipeline and opportunities
- Portals to manage engineering services
Cursor can deploy apps from new or existing repos across Cursor Origin and GitHub. Support for other git providers like GitLab is coming soon.
Controls and guardrails
When you publish an app, Cursor will run deterministic and agentic security checks to catch common issues, like secrets written in app files or exposed credentials. If a check fails, the agent tells you what it needs to fix. Nothing goes live until the checks pass and you explicitly publish the app.
Team admins can see every app and secret on the team. They can also add their own rules to the security review, approve publishes the review blocked, and unpublish any app.
Share with your team
Once the checks pass, Cursor deploys the app to the URL you chose. You can then share your app with specific people, groups, or your entire team, all behind Cursor sign-in. On individual plans, you can also share apps publicly.
You can also provision a Cursor API key if you want a script or Grok Bot to use your app.
Get started
This capability is now available on all paid plans with cloud agents enabled. Learn more by reading our docs.
Original source All of your release notes in one feed
Join Releasebot and get updates from Cursor and hundreds of other software products.
- Oct 20, 2026
- Date parsed from source:Oct 20, 2026
- First seen by Releasebot:Oct 27, 2026
Introducing the Agent SDK
Cursor releases the Agent SDK, now generally available for building, testing, and deploying custom software agents. Teams can define agents in code, connect them to workflow events, run evaluations, and deploy to Cursor infrastructure or their own.
Software teams use agents defined as code to handle recurring work across the development lifecycle. These agents connect to the places where a team works and act when relevant events occur, whether that means reviewing a pull request, executing a compliance workflow, or investigating an incident.
The most useful agents are tailored to how a particular team operates. Until now, building one has generally meant adopting a product designed around someone else's workflow or starting from scratch.
Today, we're releasing the Agent SDK, the framework we use to build our own managed agents like Bugbot, Security Reviewer, and Rollouts. Agent SDK allows you to define agents in code and manage them like any other software project. Start from a template or point your coding agent at our docs. When the agent is ready, agent-sdk deploy it to Cursor infrastructure with one command.
Build around your workflow
The Agent SDK lets you quickly build and deploy agents that work the way your team does. They respond to the events your team already handles and follow policies your team can inspect and change.
Code review is one example. Each team has its own standards for what requires attention and who should review it. With the Agent SDK, you can build an agent that responds to pull request events from GitHub, GitLab, or Bitbucket. The agent can assess the risk of a change, route it to the right team, and approve changes that meet your policy.
As an example, a team within Cursor had built a large, fast-growing knowledge base of lessons learned and wanted every pull request checked against it. This way, the team's past decisions would hold even as the codebase changed. With the Agent SDK, they built kb-reviewer in about a day. It now runs on every PR in their main codebase, flags changes that contradict a recorded lesson, cites the note behind each finding, and encourages engineers to reconcile the discrepancies it reports.
For more complicated work, agents can hand a task to another specialized agent with its own tools and sessions. They can also divide a job among subagents working in parallel.
The Agent SDK also supports evals and event replay out of the box, allowing for rapid development with assurances that critical workflows execute the way you expect. The PGA Tour uses the Agent SDK to power their software development factory. Evals keep them moving quickly.
The Agent SDK has enabled PGA to build every component of our software factory on Cursor's infrastructure. It provides the flexibility we need to build agents that drive our development process. And built-in support for evals allows us to quickly iterate on new ideas and optimize existing capabilities reliably.
Michael Gyarmathy
Principal Engineer, PGA AmericaDefine everything in code
An Agent SDK agent is organized like a small software project. The instructions that guide it sit alongside code for its tools, connections to outside services, and the evals used to test it.
Each file represents something the agent knows or can do. Prompts are written in Markdown, while tools are defined as TypeScript functions. Because everything is code, changes can go through the same version control and review process as the rest of your software.
Deploy agents wherever you need them
When you're ready to put an agent into use, you can deploy it to Cursor by running
agent-sdk deployfrom the project directory. The command builds the agent, gives it a URL, and starts it on our infrastructure. You can manage secrets and integrations from the dashboard, while continuing to use the same logs, evals, and playground available locally.You can also run the agent on your own infrastructure. Each agent runs as a single Node process that can be packaged in a container.
Get started
Getting started with the Agent SDK looks much like starting any other software project. Create a project directory, then launch the local playground:
import { homedir } from "node:os"; import { join } from "node:path"; import { defineAgent } from "@cursor/agent-sdk"; export default defineAgent({ name: "Robo", model: { id: "composer-2.5", params: [ { id: "effort", value: "high" }, { id: "fast", value: "true" }, ], }, local: { cwd: join(homedir(), ".cache", "factory", "robo"), }, })From there, you can iterate locally and run evals before deploying with
agent-sdk deploy.The Agent SDK also ships with skills that guide coding agents through the development process. You can point an agent at the docs and have it help build the bot with you.
The Agent SDK is generally available today. Read the docs and get started.
Original source - Oct 20, 2026
- Date parsed from source:Oct 20, 2026
- First seen by Releasebot:Oct 26, 2026
Agent SDK
Cursor releases the Agent SDK, now generally available for building agents as code, testing them with evals, and deploying them to Cursor or your own infrastructure. It supports event-driven channels, local development, and tools for managing and testing agents.
The Agent SDK is available today. It allows you to define an agent as a folder of code, test it with evals, and deploy it to Cursor or your own infrastructure.
Run
npx @cursor/agent-sdk init ./my-bot, thenagent-sdk devto start the bot locally with a playground. Pass--templateto start from a security reviewer, an owners-policy approver, a PR autofixer, or a Linear or Jira triager.Deploy agents wherever you need them
When you're ready to put an agent into use, you can deploy it to Cursor by running
agent-sdk deployfrom the project directory. The command builds the agent, gives it a URL, and starts it on our infrastructure. You can manage secrets and integrations from the dashboard, while continuing to use the same logs, evals, and playground available locally.Agents as code
An agent is a project.
instructions.mdis the prompt. Each file intools/is one typed action the model can call.skills/holds procedures the model loads on demand,mcp-connections/adds tools from MCP servers, andchannels/defines where the bot receives and answers messages.agent-sdk validatechecks the project andagent-sdk infoprints what was discovered.Channels
Agents wake on pull request, comment, and CI events from GitHub, GitLab, and Bitbucket; on mentions and DMs in Slack; on webhooks from any provider; and on a cron schedule. GitHub events pull through your Cursor account, so no public webhook URL is required. Slack is well-supported out of the box.
Each conversation keeps its own session and a complete record of every message and tool call. Follow-ups on a pull request or Slack thread resume the same session.
Evals
An eval sends a fixed message to the bot and asserts on what it did: which tools ran, with what input, and the shape of the reply. Run
agent-sdk evallocally or in CI.agent-sdk github replay <pr-url>turns a real pull request into signed webhook payloads and sends them to the bot, so GitHub-driven bots can be tested without waiting for a push. Add--dry-run --fixtures-dir fixtures/to save the payloads as eval fixtures.Get started
The Agent SDK is generally available today. Read the docs and get started.
Original source - Oct 16, 2026
- Date parsed from source:Oct 16, 2026
- First seen by Releasebot:Oct 17, 2026
Cloud Agent Canvases and Environment Improvements
Cursor adds interactive canvases for cloud agents, a beta Environments API, and support for 300 repositories with 5x faster loading.
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.
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.
Original source Similar to Cursor with recent updates:
- Perplexity release notes33 release notes · Latest Nov 6, 2026
- Anthropic release notes958 release notes · Latest Nov 14, 2026
- Obsidian release notes125 release notes · Latest Nov 12, 2026
- OpenClaw release notes463 release notes · Latest Nov 12, 2026
- OpenAI release notes1235 release notes · Latest Nov 13, 2026
- xAI release notes305 release notes · Latest Nov 5, 2026
- Oct 13, 2026
- Date parsed from source:Oct 13, 2026
- First seen by Releasebot:Oct 14, 2026
Origin App Marketplace
Cursor reports that Origin now connects with 20+ developer tools across deployments, CI, code review, security, monitoring, and project management. The marketplace is open to public app submissions, letting teams publish integrations after review.
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
Publish to Marketplace
To submit an app:
- Create an app in your namespace. It stays private to your namespace while you build.
- 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.
- 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.
- We review the submission and list the app once it's approved.
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.
Original source - Oct 6, 2026
- Date parsed from source:Oct 6, 2026
- First seen by Releasebot:Oct 7, 2026
Remote control for local agents
Cursor adds Remote Control in the Cursor iOS app, letting users view and reply to local agents running on their computer. The feature is available today, works without cloud agents, and is on by default for most users except Enterprise organizations.
You can now see and reply to the local agents running on your computer from the Cursor iOS app.
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.
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.
Original source - Sep 23, 2026
- Date parsed from source:Sep 23, 2026
- First seen by Releasebot:Sep 25, 2026
Improved token efficiency for longer agent runs
Cursor improves its agent harness to cut token costs by 7% while keeping quality high. It trims system prompts, loads tools dynamically, boosts cache reuse, compresses file reads, and tunes subagent behavior for longer, more efficient runs.
As agents have matured and learned to tackle more ambitious tasks, token spend has shifted. Agents now work for longer and carry more context from one step to the next, making the way we assemble and manage that context increasingly important.
Notes: System & tool defs includes compaction summaries. User text includes manually attached skills. Skills & plugins includes skill descriptions, MCP tool descriptions, and rules that go in static context.
Over the past few months we've responded to this shift by improving the efficiency of Cursor's agent harness. The harness gives us direct control over how each request is assembled, how context is reused, and when work is divided across agents. Changes across each of these layers reduced token costs for users by 7% without reducing agent quality.
Trimming the system prompt
Every agent turn includes context supplied by Cursor before the model begins working. This includes the system prompt and definitions for the tools the agent can use. Because this context is included throughout a conversation, it had become one of the largest sources of spend that we fully control.
When models were less capable, we had to spell out instructions for tool usage, task management, and code-change workflows. We also had to guard against strange behaviors like extremely long hash dumps, binary output, and emojis.
As models improved, much of that direction became unnecessary. Instead of long lists of "DO NOT do this," "You must," or "Important" instructions, we could simply define how a tool behaves and models would generally comply. This was true across model families, allowing us to trim roughly 66% of our system prompt.
Over time, we continue to add and remove instructions as new models require new guidance, which then flows into the training of future models. Leveraging A/B tests on a large user base is crucial to effectively optimizing the harness for real traffic. While evals can be a fast and useful proxy, they often represent "hard" problems and don't properly reflect the true distribution of user requests.
Loading tools only when needed
The system prompt is only one part of the context Cursor supplies on every turn. Another is tool definitions, which had grown dramatically over the course of the year as we added more powerful capabilities to the Cursor agent, including background shell monitoring, cloud subagents, and more reliable access to web content. Most of these tools are important, but each is needed in fewer than 20% of conversations.
That created an opportunity to improve efficiency by keeping tools available without including their full definitions in every request. We'd solved a similar problem earlier this year when we moved MCP tools into dynamic context, loading them only when needed. This reduced total tokens by 46.9% across sessions that called an MCP tool.
We have now applied the same technique to our own built-in tools.
To decide which tools to keep in static context, we A/B tested several configurations based on how often each tool was used and whether models needed to see it from the start. We tracked token usage, cost, latency, tool-call errors, and overall agent usage to make sure the savings did not degrade quality.
Ultimately, we kept the high-frequency tools for reading, searching, editing, and using the shell in static context. We also retained ask_question, which some models tended to hallucinate calls for, and tools that are crucial to specific product flows, such as create_plan in Plan Mode. The remaining tools now load when the agent needs them.
Improving cache reuse
After reducing the amount of static context in each request, we improved how effectively repeated context could be cached across turns.
Every agent turn resends a long request containing tools, system instructions, setup, and the conversation so far. Much of the beginning stays the same from one turn to the next, while the conversation at the end continues to grow.
Prompt caching allows the model provider to reuse that unchanged prefix. However, caching configurability can vary by provider. Before GPT-5.6, the cache boundary was determined automatically based on the latest request. Even though tools and system instructions rarely changed, they were not cleanly marked as reusable on their own.
Since GPT-5.6, the OpenAI API allows clients to mark explicit cache breakpoints alongside its default implicit caching. We now place breakpoints after stable layers of the request and before the growing conversation, allowing later turns to reuse more of the unchanged prefix.
Breakpoints only help if the prefix itself stays stable, so we also tightened what sits at the front of each request. We did this by reserving tools and system instructions for content that rarely changes, and by moving more variable setup past the cache boundaries into our "phantom user message." This holds user- and request-specific context like skills, subagents, and environment info.
These changes reduced the rate of cold cache misses by 20%.
Compressing file reads
Another large source of token spend is the context an agent adds as it works, much of which comes from reading files.
Cursor's agent reads files through a Read tool, which traditionally numbered every line because models are not good at counting lines on their own and need to cite specific sections for the user.
A single line number uses only around three to five tokens, but when an agent reads tens of thousands of lines during a session, numbering every one adds a meaningful amount of context.
We reduced that overhead by including line numbers only on every tenth line. This is still frequent enough for models to cite code properly, and the change reduced cache-read tokens by 1.6% with no reduction in quality.
Using subagents strategically
Longer agent runs create more opportunities to delegate work to subagents. This can reduce token spend because each subagent typically starts with a fresh context window rather than carrying the parent agent's full conversation. Once it reports its results, the parent can continue without carrying the subagent's full working context.
This kind of context isolation between agents and subagents does carry a coordination tax, though, because agents that do not share context can duplicate work or pursue tasks that are no longer necessary.
We made two changes to capture the efficiency benefits without adding unnecessary coordination. First, we removed instructions that strongly encouraged agents to use subagents for codebase exploration. As subagents became more prevalent in training data and researchers incorporated them into post-training, models learned this pattern natively. Removing the extra prompting produced more balanced subagent usage.
We also tightened how subagents select models. Cursor can spawn subagents using any of our available models, which makes it possible to shore up blind spots across models or pair an expensive planning model with a cheaper one for implementation. We updated the tool arguments so agents choose a different model only when directed by the user or the harness.
Continuing to improve harness efficiency
We'll continue measuring how context accumulates across longer runs and testing where the harness can reduce repeated processing without affecting agent quality. Over time, we expect this will allow token use to grow far more slowly than the amount of work agents can complete. We've also taken these learnings to Grok Bot, where we're working to optimize its unique harness so that users can accomplish the most work at the lowest cost.
Original source - Sep 23, 2026
- Date parsed from source:Sep 23, 2026
- First seen by Releasebot:Sep 25, 2026
Bots for the last mile: Rollouts, Security Review
Cursor ships software development bots that help teams get safe, reliable code into production faster. Rollouts watches changes from PR to production and flags regressions, while Security Reviewer finds and fixes security issues in codebases. Both are available today.
Today we're releasing software development bots that help you get safe, reliable code into production faster.
- Rollouts watches a change from PR to production, flags regressions, and acts to restore a healthy state.
- Security Reviewer finds and fixes security issues in your codebase.
Why we built these
Writing code is no longer the slow part. What hasn't sped up is everything after the PR goes up: making sure code is secure, watching the deploy, deciding whether a latency bump is real, figuring out which of eleven changes broke checkout.
That work is hard, repetitive, and needs a lot of context. Sounds like the type of work that bots should be doing!
We've said we're building toward self-driving codebases. Rollouts and Security Review autonomously handle common tasks every software team wishes they had more expertise and time to do.
Rollouts
Rollouts tracks a change from the moment the PR opens to the moment you're confident it works in production.
Connect source control, your deploy system, and your telemetry (Datadog, Grafana, Honeycomb, or wherever your metrics and traces live). Before merge, Rollouts reads the diff and writes a monitoring plan: the risks it sees, the effects the change is supposed to have, and the places your instrumentation can't tell you whether it worked. Edit the plan if it's missing something.
After deploy, Rollouts compares the signals in the plan against the pre-deploy baseline. When it finds a regression, it tells you which change it suspects and what it plans to do. Depending on how you've configured it, that's a ping to the author, a paused progressive rollout, or a revert PR waiting for approval.
Three things it does well today:
- It catches regressions confined to one endpoint in one region, before a global alert would fire
- It tells intended effects apart from regressions, so a deliberate spike doesn't page anyone
- It flags missing instrumentation before merge, which is the most common reason a bad change goes unnoticed
Coming soon: feature flag integration so Rollouts can ramp and unramp traffic directly, and awareness of release trains and deploy freezes.
Security Reviewer
Security Reviewer runs on every PR, reads the change in the context of the whole codebase, and reports vulnerabilities with an explanation and a proposed fix.
Static analysis pattern-matches: it flags every string concatenation near a SQL call and misses the authorization check that stopped running after a refactor. Security Review reads code the way a security engineer does: where does user input enter, where does it end up, what does it pass through on the way.
Out of the box it looks for:
- Injection across SQL, command, template, and LDAP surfaces
- Missing or broken authentication and authorization on new and changed routes
- Secrets and credentials committed to source
- Unsafe deserialization and unvalidated redirects
- Dependency changes that pull in known vulnerabilities
- Insecure defaults in infrastructure and config
Each finding has a severity, an attack path, and a one-click fix.
Get started
Rollouts and Security Reviewer are available today on Teams and Enterprise plans. Enable either bot from the automations tab to get started.
Original source - Sep 23, 2026
- Date parsed from source:Sep 23, 2026
- First seen by Releasebot:Sep 25, 2026
Rollouts and Security Review
Cursor launches two new bots for shipping code faster and safer. Rollouts monitors pull requests through deployment and reports health by environment, while Security Review flags exploitable bugs in every PR. Both are available now on Teams and Enterprise plans.
Rollouts
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.
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.
Original source - Sep 10, 2026
- Date parsed from source:Sep 10, 2026
- First seen by Releasebot:Sep 11, 2026
Cursor Projects
Cursor launches Projects, a new beta workspace for larger coding efforts that keeps context over months, delegates work to agents, runs in the cloud, and can react to signals like Slack, schedules, and PRs while rolling out to all users today.
Projects in Cursor
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.
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.
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.
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.
Original source - Sep 10, 2026
- Date parsed from source:Sep 10, 2026
- First seen by Releasebot:Sep 10, 2026
Introducing Projects
Cursor launches Projects, a beta feature for tackling larger bodies of work with a coordinator agent that delegates to thousands of subagents, keeps shared context over time, and can run on schedules or respond to signals like Slack and PRs.
Direct thousands of agents through one coordinator
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.
In February we outlined our vision for a third era of software development, where fleets of agents take on entire bodies of work. Projects is the concrete implementation of that vision. By moving up a level of abstraction, it frees developers from managing agents and lets them direct the work itself.
At Cursor, we've been using Projects for several months, doing work such as running migrations of a few hundred PRs, keeping our design system consistent, and shipping Projects itself. We've found it to be a substantial productivity multiplier: new users merge 30% more PRs while users who primarily use Projects merge six times as many.
You oversee a Project by chatting with its coordinator agent. The coordinator doesn't write code itself but directs other agents that do. Because it delegates rather than executes, it is never blocked and is always responsive to direction.
There are three core capabilities that make Projects possible:
Cloud by default, local when needed. A Project runs on its own computer, so closing your laptop doesn't stop it. This lets a Project run more subagents in parallel than your laptop could support. 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. This context grows with the Project, making the coordinator more effective over time.
Subscriptions. The coordinator can watch a Slack channel, run on a schedule, or follow all your PRs, fixing CI and acting when they open or merge. This way it can take action based on signals it detects, without waiting for you to prompt it.
How we use Projects at Cursor
Three patterns cover most of what our engineers do with Projects.
Feature work
Most engineers create a Project for a substantial body of work. A feature usually starts with agents researching the system and recording what they learn as shared context. The coordinator then creates a plan and sends agents to implement and test different parts of it in parallel.
With each turn of feedback, the Project learns your architecture and preferences. When the feature is ready to try, the coordinator can start an agent on your computer and run it locally. After it ships, the same Project can monitor logs and handle bug reports with the full context behind the original decisions.
Migrations
Projects are especially useful for migrations that are easy to start and difficult to finish. At Cursor, we've used them to adopt new frameworks and replace styling systems across hundreds of PRs.
You work with the coordinator to establish a safe approach, then it applies that approach incrementally across the codebase. Early on, you review each PR closely. As the fixes hold up, you review less, and the coordinator keeps working through the migration on its own.
Gardening
Projects are great for handling work that never really ends, such as maintaining code quality or watching for regressions. You can tell the coordinator to follow new PRs, listen for bug reports in Slack, or run on a schedule, and it acts whenever new work appears.
One engineer on our team runs a design-system Project this way. At first, the engineer reviewed each fix and corrected the ones it got wrong. Now the coordinator scans every new PR, extracts components that belong in the design system, and adds a lint rule whenever it sees the same mistake twice. The Project is on track to touch 20 to 100 PRs a day, so the coordinator organizes the work and the engineer checks in where attention is needed.
Get started with Projects
Projects are available in beta and rolling out to all users starting today. Start a Project from the left hand nav, describe what you want built, and the coordinator takes it from there. It works best on work that will outlive a single chat, whether that's a feature with several PRs, a migration, or a job you want handled while you're away.
Original source - Sep 2, 2026
- Date parsed from source:Sep 2, 2026
- First seen by Releasebot:Sep 3, 2026
Self-hosted machines
Cursor adds self-hosted machines for local tool execution, keeping code, builds, and secrets inside your network. It also brings dynamic machine pools, support for cloud agents on existing infrastructure, and computer use on Linux and Mac for browser and desktop control.
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.
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.
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.
Original source - Sep 2, 2026
- Date parsed from source:Sep 2, 2026
- First seen by Releasebot:Sep 2, 2026
Run cloud agents on machines you manage
Cursor adds Self-Hosted Machines for cloud agents, letting teams run agents on their own infrastructure while Cursor still manages planning and orchestration. It also expands pool scaling, sandbox provider support, and Linux computer use for more flexible, secure agent workflows.
Cursor cloud agents can execute on dynamically scheduled pools of machines inside your network. You manage the underlying infrastructure, while agents are still started and managed from Cursor.
This gives teams more control over where agents execute and what infrastructure they use. Agents can work next to internal services and source control, run on custom hardware, or use operating systems and build pipelines that are difficult to package as a Cloud Agent build.
Cloud agents now create more than 60% of the pull requests we merge internally and are taking on a growing share of software work at many of the largest enterprises we work with. As their role expands, the machines they run on matter more too. These new capabilities make it practical for teams to provide and manage that infrastructure at scale.
With Lambda MicroVMs as the compute layer for Cursor Cloud Agents, developers can run AI-powered coding agents in their own AWS account. Each machine launches near-instantly from a snapshot, suspends when idle, and resumes with full state. Your coding agents benefit from Lambda's fast startup, strong isolation, and zero fleet management, while Cursor orchestrates the work.
Control where agents execute
Cursor-hosted environments remain the default for cloud agents. Each session runs on a dedicated VM inside the Cursor cloud, with its dependencies installed and its own network controls. Per-agent isolation, secret redaction, egress controls, and signed commits meet the security requirements of most teams.
Teams generally use Self-Hosted Machines when:
- Agent tool execution needs to happen inside their network, with direct access to source control, internal services, and code repositories.
- Agents require custom hardware, such as GPUs or Macs for iOS development, or infrastructure such as Kubernetes, sandboxes, or managed VMs.
- Their operating system or build pipeline is difficult to package as a Cloud Agent build.
With Self-Hosted Machines, only the execution environment moves while the agent loop, inference, and planning remain in the Cursor cloud. Tool outputs flow back to Cursor for inference and may contain code, and agent transcripts may be processed and stored by Cursor. Teams can continue to access cloud agents from the desktop app, cursor.com, mobile, Slack, GitHub, and Linear.
Workers connect your infrastructure to the Cursor agent loop
With Self-Hosted Machines, tool execution moves from a Cursor-hosted VM to a machine in your environment. That machine holds the working copy of the repository, edits files, and runs commands. A worker connects it to the rest of the agent system.
To register a machine, run a worker by installing the Cursor CLI and running
agent worker startThis opens a long-lived outbound HTTPS connection to the Cursor cloud. When a session begins, Cursor's agent harness handles inference and planning, then sends tool calls to a dedicated worker for execution. The worker returns the results for the next round of inference. Cursor never initiates a connection into your network.
Workers can be configured in two ways.
- My Machines. This configuration connects a single laptop or VM to your account and is best suited to personal workflows.
- Pools. A pool is a named queue of workers that can serve a team or enterprise. Capacity increases as requests arrive and decreases after workers disconnect, letting your existing cloud infrastructure scale with developer demand.
Developers should have the flexibility to run coding agents on the platform that best supports their workflow, and companies should not have to compromise on control of where agents run and what they can access. The future of development will be built on powerful agents, running in secure, isolated environments.
Cloud agents adapt to your infrastructure
Worker pools can now scale in response to queued requests and serve work from any repository. We have also added support for several sandbox providers and computer use on Linux alongside Mac.
Pools scale with demand and serve any repository
Demand for cloud agents often arrives in bursts and Self-Hosted Machines pools adjust to those bursts automatically. This happens through a controller which watches the request queue and uses a spawn script supplied by the team to start machines as needed.
If a pool has an available worker, that worker claims the request. Otherwise, the request waits until more capacity becomes available, so teams do not have to decide how many machines to leave running.
Teams can set an idle timeout for each worker connection. Once it expires, the machine can reset and re-enter the pool. Teams can also preserve its workspace in case the agent receives a follow-up.
Self-Hosted Machines put teams in control of where Cursor agents run, and Vercel Sandbox makes it effortless. Every task gets an isolated sandbox on demand, no fleet to manage, and nothing sitting idle.
Leaving a machine running while its agent is idle can be expensive. But if the machine is released, the agent may need several minutes to reconstruct its workspace when a follow-up arrives. With hibernation, teams can snapshot and stop an idle machine instead. If a follow-up arrives within the reconnect window, the snapshot is restored and a worker starts with the same ID. Otherwise, the request can move to a new machine.
Pools are not tied to individual repositories. A request only needs to identify the pool, and any available worker can claim it. This lets one pool serve many repositories.
Workers run across supported sandbox providers
Self-Hosted Machines does not require building a custom sandbox layer from scratch. We partner with AWS Lambda, Cloudflare, Coder, Daytona, E2B, Modal, Namespace, and Vercel, allowing workers to be started and orchestrated wherever a team's sandboxes already run.
Cursor Self-Hosted Machines on Modal gives each Cloud Agent session a Modal Sandbox, so you can hand it a machine tailor-made for its task.
Agents control browsers on Linux and Mac
Linux workers now support computer use alongside Macs. With the required computer use dependencies installed, including Chrome or Chromium, an agent can click, take screenshots, and control the browser. You can watch its desktop or take control directly from Cursor.
You can't build iOS or macOS apps without a Mac. Namespace Devboxes spin up a real Mac for each Cursor Cloud Agent, which can now perform that work on Apple silicon.
Bring cloud agents into your environment
Teams have spent years shaping their infrastructure around how they build software. Self-Hosted Machines lets cloud agents fit more naturally into it, and we're excited to see how far teams take them.
To connect a machine or configure a pool, get started in the docs.
Original source - Aug 27, 2026
- Date parsed from source:Aug 27, 2026
- First seen by Releasebot:Aug 27, 2026
Start from scratch, without a repo
Cursor adds a smoother Cloud Agents workflow that starts without a connected GitHub or other SCM provider, then lets users save work to a Cursor Origin repo, preview live in the browser, and publish to Vercel with a live URL.
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.
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.
Original source
Curated by the Releasebot team
Releasebot is an aggregator of official release notes from hundreds of software vendors and thousands of sources.
Our editorial process involves the manual review and audit of release notes procured with the help of automated systems.