Cursor Release Notes

When coding agents receive a prompt, returning the right answer requires building an understanding of the codebase by reading files and searching for relevant information.
One tool Cursor’s agent uses is semantic search, which retrieves segments of code matching natural language queries, such as “where do we handle authentication?”, in addition to the regex-based searching provided by a tool like grep.
To support semantic search, we’ve trained our own embedding model and built indexing pipelines for fast retrieval. While you could rely exclusively on grep and similar command-line tools for search, we've found that semantic search significantly improves agent performance, especially over large codebases:

• Achieving on average 12.5% higher accuracy in answering questions (6.5%–23.5% depending on the model).
• Producing code changes that are more likely to be retained in codebases.
• Requiring fewer iterations for users to arrive at a correct solution.
• Increasing accuracy across all models we tested, including all frontier coding models.

Offline evals
We maintain an evaluation dataset, Cursor Context Bench, focused on retrieving information in codebases with known correct answers. This evaluation is run over all of the most-used models in Cursor, including our own Composer.
The comparison looks at performance with two sets of available tools: one that includes semantic search and one that does not. In every configuration, semantic search significantly improves outcomes.

Online A/B tests
We also wanted to understand the impact on the end-user experience. We ran an A/B test where both groups used the same model, but one group's agent had access to semantic search while the other relied solely on traditional search tools like grep. We looked at two metrics:

• Code Retention: Code written by effective agents is more likely to remain in user codebases. We see agent code retention increases by 0.3% when semantic search is available. This effect increases to 2.6% on large codebases with 1,000 files or more.
• Dissatisfied User Requests: Code written by effective agents requires no follow-ups or corrections. We observed a 2.2% increase in dissatisfied follow-up user requests when semantic search was not available.
  The effect size is lower here since the A/B test is on all agent queries and not all requests require search.

Custom retrieval models
One piece that enables these results is our custom embedding model. Our approach uses agent sessions as training data: when an agent works through a task, it performs multiple searches and opens files before finding the right code. By analyzing these traces, we can see in retrospect what should have been retrieved earlier in the conversation.
We provide these traces to an LLM, which ranks what content would have been most helpful at each step. We then train our embedding model to align its similarity scores with these LLM-generated rankings. This creates a feedback loop where the model can learn from how agents actually work through coding tasks, rather than relying on generic code similarity.

Conclusion
Semantic search is currently necessary to achieve the best results, especially in large codebases.
Our agent makes heavy use of grep as well as semantic search, and the combination of these two leads to the best outcomes. We’re continuing to test and evaluate all tools we give to the agent harness as models improve.

Original source Report a problem

Cursor is used by tens of thousands of enterprises, including Salesforce, NVIDIA, and PwC, to accelerate product velocity and build durable software.
To further support enterprise teams, we’re launching new features that make Cursor’s coding agents more capable, transparent, and secure.

Hooks

Hooks allow you observe, control, and extend the agent loop using custom scripts.

{
"version" : 1 ,
"hooks" : {
"beforeSubmitPrompt" : [
{
"command" : "./audit.sh"
}
],
"beforeShellCommand" : [
{
"command" : "./audit.sh"
},
{
"command" : "./allowlist.sh"
}
]
}
}

Integrating Cursor Hooks with our engineering intelligence platform

gives us a better sense of how AI is affecting developer productivity throughout the software development lifecycle, and gives engineering leaders the insights they need to make smarter decisions.

Rebecca Fitzhugh
Lead Principal Engineer, Atlassian

Hooks can

• Add observability: Log agent actions, tool calls, prompts, and completions for future analysis.
• Control the full agent loop: Enforce compliance policies, block unapproved commands, and scrub secrets or proprietary code in real time.
• Extend Cursor with code: Connect external systems, inject context, or trigger automations.

Hooks can be distributed through MDM or with Cursor’s cloud option.

Team Rules

Team Rules bring shared context and best practices to every developer in your organization.

Team Rules make it easy for our agents to stay aligned with how we build at Duolingo. They guide developers toward the right patterns automatically, so we spend less time fixing and more time shipping.

Sarah Deitke
Software Engineer, Duolingo

Rules can standardize API schemas, enforce conventions, or teach common workflows. Admins can choose to recommend or require rules from the cloud dashboard.

Upgraded Analytics

We’ve rebuilt our analytics to give leaders data about how their teams use AI:

• See daily activity and top users at a glance
• Data on CLI, Background Agent, and Bugbot adoption
• View percentage of AI lines of code on the commit level
• Filter data by Active Directory group
• Exportable replication data per visualization (via API or CSV)
• Data updates every two minutes instead of every 24 hours

The new usage leaderboard has already helped us surface power users and learn how they work. The cleaner dashboard makes the data easier to trust and act on.

Nicolas Arkhipenko
Senior Director of AI Platforms & Developer Productivity, Salesforce

The upgraded dashboard is generally available today, with data from August 27th for all clients 1.7 and later.

Audit Log

Audit Log gives administrators full visibility into every key event on the platform from security changes to rule updates.
It currently tracks 19 event types covering access, asset edits, and configuration updates.
Audit Log data is available in the web dashboard and can be exported as a CSV.

Sandbox Mode

Sandbox Mode executes agent terminal commands in a restricted environment to enable faster and safer iteration.
By default, the sandbox blocks network access, limiting file access to the workspace and /tmp/ .
If a command fails due to restrictions, the user can skip it or choose to re-run outside the sandbox.
Enterprise Admins have control over sandbox availability and team-wide git and network access.

Working with our team

We want to make Cursor the best place for teams building with AI. Many of these features were inspired by the work we're already doing with many of the most innovative companies in the world, and we’d like to build with yours.

Original source Report a problem

Raw content:
Cloud agents make it easy to run many agents at once, without requiring your laptop to stay connected to the internet.
You can now manage cloud agents from your Cursor editor, and access them from anywhere using a significantly improved cursor.com/agents.

How Cursor Uses Cloud Agents

1. Fixing Bugs
   It’s now often faster to kick off a cloud agent from Slack or Cursor than it is to add an issue to a tracker like Linear.
   The ability to quickly hand off bug fixes to cloud is especially useful when we’re working on something important, and come across a bug that we don’t want to get distracted by. We just kick off cloud agents to fix it in the background, and come back to check the solution whenever we’re ready.
   We will usually have multiple models attempt the same problem and pick the best result. We’ve found that this significantly improves the final output, especially for harder bugs that may require a handful of precise changes to be fully resolved.

2. Quick Todos
   The list of things we want to do has always been much longer than the list of things we have time for. Now we’re finding that smaller todos can be quickly handed over to cloud agents—often when planning our day in the morning, or kicking off some tasks before lunch.
   Some of us commute to work, and use cursor.com/agents to put a set of cloud agents to work before we even arrive at the office.

3. Assisting with Complex Features
   For more complex features, we’ve had success using cloud agents to take over once we have a detailed plan in place and have determined how we want the feature to be implemented. Cursor's plan mode supports sending plans to be implemented in the cloud. We will often iterate with a model locally to create a plan, and then move on to the next task while a cloud agent implements the changes.
   We have also revamped the GPT-5 Codex agent harness to work better for long time horizons in the cloud.

Start building
We are excited for you to try the new Cloud Agents workflow. You can try Cloud Agents today in the Cursor editor and Cursor Web, as well as Slack, Linear, and GitHub.

Original source Report a problem

Multi-Agents

Manage agents in our new editor, with a sidebar for your agents and plans.
Run up to eight agents in parallel on a single prompt. This uses git worktrees or remote machines to prevent file conflicts. Each agent operates in its own isolated copy of your codebase.

Composer

Introducing our first agentic coding model. Composer is a frontier model that is 4x faster than similarly intelligent models.

Browser (GA)

Launched in beta in 1.7, browser for Agent is now GA. We’ve added additional support for Enterprise teams to use Browser in 2.0.
Browser can now be embedded in-editor, including powerful new tools to select elements and forward DOM information to the agent. Learn more about using the browser.

Improved Code Review

It’s now easier to view all changes from Agent across multiple files without needing to jump between individual files.

Sandboxed Terminals (GA)

Launched in beta in 1.7, sandboxed terminals are now GA for macOS. We now run agent commands in the secure sandbox by default on macOS with 2.0.
Shell commands (that are not already allowlisted) will automatically run in a sandbox with read/write access to your workspace and no internet access. Learn more about sandboxing.

Team Commands

Define custom commands and rules for your Team in the Cursor dashboard.
This context will then be automatically applied to all members of your team, without needing to store the files in your editor locally, and centrally managed by team admins.

Voice Mode

Control Agent with your voice using built-in speech-to-text conversion. You can also define custom submit keywords in settings to trigger the agent to begin running.

Improved Performance

Cursor uses Language Server Protocols (LSPs) for language-specific features like go to definition, hover tooltips, diagnostics, and more.
We've drastically improved the performance of loading and using LSPs for all languages. This is particularly noticeable when working with agent and viewing diffs.
Python and TypeScript LSPs now are faster by default for large projects with higher memory limits dynamically configured based on available RAM.
We've also fixed a number of memory leaks and improved overall memory usage.

Plan Mode in Background

Create your plan with one model and build the plan with another. You can choose to build the plan in the foreground or background, or even plan with parallel agents to have multiple plans to review.

Shareable Team Commands

Share custom rules, commands, and prompts with your entire team. Create deeplinks through the Cursor Docs.

Improved Prompt UI

Files and directories are now shown inline as pills. We've also improved copy/pasting prompts with tagged context.
We've removed many explicit items in the context menu, including @Definitions, @Web, @Link, @Recent Changes, @Linter Errors, and others. Agent can now self-gather context without needing to manually attach it in the prompt input.

Improved Agent Harness

We've greatly improved the underlying harness for working with Agent across all models. This has notable quality improvements, especially for GPT-5 Codex.

Cloud Agents

Cloud agents now offer 99.9% reliability, instant startup, and a new UI coming soon. We've also improved the experience of sending agents to the cloud from the editor.

Cursor for Enterprise

Sandboxed Terminals: Admin Controls

Enterprise can now enforce standard settings for Sandboxed Terminals across their team. Configure sandbox availability, git access, and network access at the team level.

Hooks: Cloud Distribution

Enterprise teams can now distribute hooks directly from the web dashboard. Admins can add new hooks, save drafts, and select which hooks should apply to which operating systems.

Audit Log

View a timestamped log of admin events in Cursor: user access, setting changes, Team Rule edits, and member management events.

Original source Report a problem

Overview

Composer is our new agent model designed for software engineering intelligence and speed. On our benchmarks, the model achieves frontier coding results with generation speed four times faster than similar models.

We achieve these results by training the model to complete real-world software engineering challenges in large codebases. During training, Composer is given access to a set of production search and editing tools and tasked with efficiently solving a diverse range of difficult problems. The final result is a large-scale model optimized for high-speed use as an agent in Cursor.

Our motivation comes from our experience developing Cursor Tab, our custom completion model. We found that often developers want the smartest model that can support interactive use, keeping them in the flow of coding. In our development process, we experimented with a prototype agent model, codenamed Cheetah, to better understand the impact of faster agent models. Composer is a smarter version of this model that keeps coding delightful by being fast enough for an interactive experience.

Model and Training

Composer is a mixture-of-experts (MoE) language model supporting long-context generation and understanding. It is specialized for software engineering through reinforcement learning (RL) in a diverse range of development environments. At each iteration of training, the model is given a problem description and instructed to produce the best response, be it a code edit, a plan, or an informative answer. The model has access to simple tools, like reading and editing files, and also more powerful ones like terminal commands and codebase-wide semantic search.

Evaluation

To measure progress, we constructed an evaluation that measures a model's usefulness to a software developer as faithfully as possible. Our benchmark, Cursor Bench, consists of real agent requests from engineers and researchers at Cursor, along with hand-curated optimal solutions to these requests. The resulting evaluation measures not just the agent’s correctness, but also its adherence to a codebase's existing abstractions and software engineering practices.

Reinforcement Learning and Behavior

Reinforcement learning allows us to actively specialize the model for effective software engineering. Since response speed is a critical component for interactive development, we incentivize the model to make efficient choices in tool use and to maximize parallelism whenever possible. In addition, we train the model to be a helpful assistant by minimizing unnecessary responses and claims made without evidence. We also find that during RL, the model learns useful behaviors on its own like performing complex searches, fixing linter errors, and writing and executing unit tests.

Training Infrastructure

Efficient training of large MoE models requires significant investment into building infrastructure and systems research. We built custom training infrastructure leveraging PyTorch and Ray to power asynchronous reinforcement learning at scale. We natively train our models at low precision by combining our MXFP8 MoE kernels with expert parallelism and hybrid sharded data parallelism, allowing us to scale training to thousands of NVIDIA GPUs with minimal communication cost. Additionally, training with MXFP8 allows us to deliver faster inference speeds without requiring post-training quantization.

Tooling and Environments

During RL, we want our model to be able to call any tool in the Cursor Agent harness. These tools allow editing code, using semantic search, grepping strings, and running terminal commands. At our scale, teaching the model to effectively call these tools requires running hundreds of thousands of concurrent sandboxed coding environments in the cloud. To support this workload, we adapted existing infrastructure we built for Background Agents, rewriting our virtual machine scheduler to support the bursty nature and scale of training runs. This enabled seamless unification of RL environments with production environments.

Cursor builds tools for software engineering, and we make heavy use of the tools we develop. A motivation of Composer development has been developing an agent we would reach for in our own work. In recent weeks, we have found that many of our colleagues were using Composer for their day-to-day software development. With this release, we hope that you also find it to be a valuable tool.

¹ Benchmarked on an internal benchmark in the Cursor tool harness. We group models into classes based on score and report the best model in each class. "Fast Frontier" includes models designed for efficient inference such as Haiku 4.5 and Gemini Flash 2.5. "Best Open" includes recent open weight model releases such as Qwen Coder and GLM 4.6. "Frontier 7/2025" is the best model available in July of this year. "Best Frontier" includes GPT-5 and Sonnet 4.5, which both outperform Composer. For the Tokens per Second calculation, tokens are standardized across models to the latest Anthropic tokenizer.

Original source Report a problem

Introducing Composer

Composer is a frontier model that is 4x faster than similarly intelligent models.
The model is built for low-latency agentic coding in Cursor, completing most turns in under 30 seconds. Early testers found the ability to iterate quickly with the model delightful and trust the model for multi-step coding tasks.
Composer was trained with a set of powerful tools including codebase-wide semantic search, making it much better at understanding and working in large codebases.

The multi-agent interface

The first thing you’ll notice when you open Cursor is our new interface.
It’s more focused and designed from the ground up to be centered around agents rather than files. So you can focus on the outcomes you want while agents take care of the details. When you need to dive deep into the code, you can still easily open files in the new layout or switch back to the classic IDE.

Cursor 2.0 makes it easy to run many agents in parallel without them interfering with one another, powered by git worktrees or remote machines. We’ve even found that having multiple models attempt the same problem and picking the best result significantly improves the final output, especially for harder tasks.

As we use agents more for coding, we’ve seen two new bottlenecks emerge: reviewing code and testing the changes. With Cursor 2.0, we’re also starting to solve both of these. We’ve made it much easier to quickly review the changes an agent has made and dive deeper into the code when you need to. We’ve also built a native browser tool that allows Cursor to test its work and iterate until it has produced the correct final result.

Start building

Cursor 2.0 is now available: cursor.com/download.
View the full changelog to see all features.

Original source Report a problem

Cursor can now create plans, research your codebase, and run longer agents.

Plan mode gives the model new tools to create and update plans, as well as an interactive editor to modify plans inline. Most new features at Cursor now begin with Agent writing a plan. We’ve seen this significantly improve the code generated.

When you prompt Agent to create a plan, Cursor researches your codebase to find relevant files, review docs, and ask clarifying questions. When you’re happy with the plan, it creates a Markdown file with file paths and code references. You can edit the plan directly, including adding or removing to-dos.

How to use Plan Mode

• Start planning by pressing Shift + Tab in the agent input.
• Answer clarifying questions on your requirements for the best output quality.
• Review or edit the detailed plan, then build directly from your plan when ready.
• Optionally, save the plan as a Markdown file in your repository for future reference.

Cursor will also suggest plan mode automatically when you describe complex tasks.

Try Plan Mode in our latest release.

Original source Report a problem

Browser Controls

Agent can take screenshots, improve UI, and debug client issues. Read more about browser capabilities.

Plan Mode

Cursor can now write detailed plans before starting complex tasks. This allows agents to run for significantly longer.

Autocomplete for Agent

When writing prompts, autocomplete suggestions will appear based on recent changes. Tab to accept suggestions and attach files to context.

Hooks (beta)

You can now observe, control, and extend the Agent loop using custom scripts. Hooks give you a way to customize and influence Agent behavior at runtime.
Use Hooks to audit Agent usage, block commands, or redact secrets from context. It's still in beta and we'd love to hear your feedback.

Team rules

Teams can now define and share global rules from the dashboard that will be applied to all projects. We’ve also shipped team rules for Bugbot, so behavior is consistent across repos.

Share prompts with deeplinks (beta)

Generate shareable deeplinks for reusable prompts. Useful for setup instructions in documentation, team resources, and sharing workflows. See our documentation for how to create them.

Sandboxed terminals

Commands now execute in a secure, sandboxed environment. If you’re on allowlist mode, non-allowlisted commands will automatically run in a sandbox with read/write access to your workspace and no internet access.
If a command fails and we detect the sandbox was the cause, you’ll be prompted to retry outside of the sandbox.

PR summaries from Bugbot

When creating a PR in GitHub, Bugbot will now generate a summary of the changes. The summary will be updated as you push changes so it's always correct. This can be disabled in the Bugbot tab of your Cursor dashboard.

Monitor Agents from menubar

Quickly check the status of Cursor Agents right from your menubar.

Image file support for Agent

Agent can now read image files directly from your workspace and include them in context. Previously, only pasted images were supported.

Original source Report a problem

You can now create reusable prompts and quickly share them with your team. Commands are stored in .cursor/commands/[command].md. Run them by typing / in the Agent input and selecting the command from the dropdown menu.

We’ve been using them for running linters, fixing compile errors, and creating PRs with detailed descriptions and conventional commits.

Cursor automatically summarizes long conversation for you when reaching the context window limit. You can now summarize context on-demand with the /summarize slash command. This can be useful when you don't want to create a new chat, but want to free up space in the context window.

We’ve added support for MCP Resources. Resources allow servers to share data that provides context to language models, such as files, database schemas, or application-specific information.

Additionally, interpolated variables are now supported for MCP. This enables using environment variables in strings when defining configuration for MCP servers.

When Agent decides to create a terminal to run shell commands, we’ve dramatically improved the stability and reliability of the environment.

This solves known issues around terminal commands hanging and not properly exiting when completing tasks, as well as improving the SSH experience.

We’ve also polished the terminal UI, made it faster to run, and added OS notifications when shell commands require user approval.

Original source Report a problem

What's New

Background Agents

You can now start Background Agents directly from Linear. Delegate tasks to Cursor without leaving your issue. We’ve written a longer blog post with more details.

Terminal

The terminal now opens on the left with a clear backdrop and border animation to highlight when it’s blocking. Rejecting auto-focuses the input so you can respond immediately.

Notifications

Get native OS notifications when an agent run finishes or when input is required, for example approving a command that is not allowlisted. Enable from Settings.

MCP elicitation

Cursor now supports MCP elicitation, a new feature in the MCP spec that allows servers to request structured input from users, such as a user preference or configuration choice. Requests are defined with JSON schemas, giving servers validated responses while ensuring users stay in control of what they share.

Original source Report a problem