Cursor Release Notes

Last month, we launched the Cursor Marketplace to make it easier to connect Cursor to your existing tools and knowledge.

Today, we're adding more than 30 new plugins from partners such as Atlassian, Datadog, GitLab, Glean, Hugging Face, monday.com, and PlanetScale. Cursor can now read from, write to, and take actions across more of your stack.

You can install plugins on the Cursor Marketplace, or build your own and share them with the community. On Teams and Enterprise plans, Admins can also create team marketplaces for distributing and managing private plugins.

Agents that work more independently

We've found that what matters most for an agent's success is access to the right tools and context. Plugins provide that by bundling capabilities like MCPs with skills that instruct the agent on how to use it. Since the initial release of Cursor Marketplace, users have reported that this combination is much more powerful than MCPs on their own.

The plugins we're introducing today span the entire development workflow, equipping agents to work more independently. Two broad buckets we're particularly excited about are infrastructure and productivity tools.

Infrastructure

• Use natural language to query logs, metrics, traces, and dashboards with the Datadog plugin.
• View and manage issues, merge requests, pipelines, and repositories with the GitLab plugin.
• Discover and apply schema recommendations, improve query performance, and work with your data in natural language with the PlanetScale plugin.

Productivity

• Search and manage issues, generate status reports, and convert specs into backlogs with the Atlassian plugin.
• Search company knowledge, and find project owners and stakeholders with the Glean plugin.
• Access and manage project boards and tasks with the monday.com plugin.

Tools for automations

Most plugins contain MCPs that cloud agents can use when kicked off manually or invoked automatically. You can use Cursor Automations to build always-on agents that run on schedules or are triggered by events. They follow your custom instructions, and can use tools like the Datadog MCP to investigate logs depending on the task they're configured to complete.

Try out the new plugins at cursor.com/marketplace, or learn more in the docs.

Original source Report a problem

We're introducing Cursor Automations to build always-on agents.

These agents run on schedules or are triggered by events like a sent Slack message, a newly created Linear issue, a merged GitHub PR, or a PagerDuty incident. In addition to these built-in integrations, you can configure your own custom events with webhooks.

“I love that automations work for both quick wins and more complex workflows. I can schedule the obvious stuff in seconds, but I still have full flexibility to catch any webhook or plug into custom MCPs when I need to.”

Trent Haines
Software Engineer, Decagon

Upgrading the software engineering pipeline

With the rise of coding agents, every engineer is able to produce much more code. But code review, monitoring, and maintenance haven’t sped up to the same extent yet. At Cursor, we’ve been using automations to help scale these other parts of the development lifecycle.

When invoked, the automated agent spins up a cloud sandbox, follows your instructions using the MCPs and models you've configured, and verifies its own output. Agents also have access to a memory tool that lets them learn from past runs and improve with repetition.

As we’ve run more automated agents on our own codebase at Cursor over the past several weeks, two categories of automations have emerged.

Review and monitoring

Automations are great for reviewing changes. They can catch and fix everything from style nits and inconsistencies to security vulnerabilities and performance regressions.

In fact, Bugbot is in many ways the original automation! It runs when a PR is opened or updated, gets triggered thousands of times a day, and has caught millions of bugs since we first launched it. Automations allow you to customize all kinds of review agents for different purposes. Here are three we use at Cursor:

• Security review
  Our security review automation is triggered on every push to main. This way, the agent can work for longer to find more nuanced issues without blocking the PR. It audits the diff for security vulnerabilities, skips issues already discussed in the PR, and posts high-risk findings to Slack. This automation has caught multiple vulnerabilities and critical bugs at Cursor.

• Agentic codeowners
  On every PR open or push, this automation classifies risk based on blast radius, complexity, and infrastructure impact. Low-risk PRs get auto-approved. Higher-risk PRs get up to two reviewers assigned based on contribution history. Decisions are summarized in Slack and logged to a Notion database via MCP so we can audit the agent’s work and tweak the instructions.

• Incident response
  When triggered by a PagerDuty incident, this automation kicks off an agent that uses the Datadog MCP to investigate the logs and looks at the codebase for recent changes. It then sends a message in a Slack channel to our on-call engineers, with the corresponding monitor message and a PR containing the proposed fix. This has significantly reduced our incident response time.

Chores

We’ve also found automations useful for everyday tasks and knowledge work that require stitching together information across different tools.

• Weekly summary of changes
  This automation posts a weekly Slack digest summarizing meaningful changes to the repository in the last seven days. The agent highlights major merged PRs, bug fixes, technical debt, and security or dependency updates.

• Test coverage
  Every morning, an automated agent reviews recently merged code and identifies areas that need test coverage. It follows existing conventions when adding tests and only alters production behavior when necessary. The agent then runs relevant test targets before opening a PR.

• Bug report triage
  When a bug report lands in a Slack channel, this automation checks for duplicates and creates an issue using Linear MCP. The agent then investigates the root cause in the codebase, attempts a fix, and replies in the original thread with a summary.

How Rippling uses automations

Teams outside Cursor have already started building automations. Abhishek Singh at Rippling set up a personal assistant. He dumps meeting notes, action items, TODOs, and Loom links into a Slack channel throughout the day. A cron agent runs every two hours, reads everything alongside his GitHub PRs, Jira issues, and Slack mentions, deduplicates across sources, and posts a clean dashboard.

He also runs Slack-triggered automations for creating Jira issues from threads and summarizing discussions in Confluence. Singh and Rippling have extended their use of automations to handle tasks like incident triage, weekly status reports, on-call handoff, and more. The most useful automations get shared across the team.

“Automations have made the repetitive aspects of my work easy to offload. By making automations to round up tasks, deal with doc updates, and respond to Slack messages, I can focus on the things that matter. Anything can be an automation!”

Tim Fall
Senior Staff Software Engineer, Rippling

The factory that creates your software

All of these automations are powered by cloud agents that use their own computers to build, test, and demo their work. Now you can build the factory that creates your software by configuring agents to continuously monitor and improve your codebase.

“We built our software factory using Cursor Automations with Runlayer MCP and plugins. We move faster than teams five times our size because our agents have the right tools, the right context, and the right guardrails.”

Tal Peretz
Co-founder, Runlayer

Try creating an automation at cursor.com/automations, or start from a template. Learn more in the docs.

Original source Report a problem

Cursor automations

Cursor now supports automations for building always-on agents that run based on triggers and instructions you define.

Automations run on schedules or are triggered by events from Slack, Linear, GitHub, PagerDuty, and webhooks.

When invoked, the agent spins up a cloud sandbox and follows your instructions using the MCPs and models you've configured. Agents also have access to a memory tool that lets them learn from past runs and improve with repetition.

Create automations at cursor.com/automations, or start from a template. Read more in our announcement.

Original source Report a problem

Cursor ACP in JetBrains IDEs

Cursor is now available in IntelliJ IDEA, PyCharm, WebStorm, and other JetBrains IDEs through the Agent Client Protocol (ACP).

With Cursor ACP, developers who rely on JetBrains for Java and multilanguage support can use any frontier model from OpenAI, Anthropic, Google, and Cursor for agent-driven development.

Install the Cursor ACP directly in your JetBrains IDE from the ACP Registry, and authenticate with your existing Cursor account.

Read more in our announcement.

Original source Report a problem

Coding with Cursor in JetBrains IDEs

Using Cursor ACP in JetBrains IDEs offers many of the benefits that make our agents effective across all surfaces.
Different models are better suited for different kinds of tasks. With Cursor ACP, developers can explore and choose frontier models from OpenAI, Anthropic, Google, and Cursor. Our agent harness is also custom-built for every model to optimize output quality and performance.
Cursor also uses secure codebase indexing and semantic search to understand large enterprise codebases. ACP combines these capabilities with deep code intelligence and tooling in JetBrains IDEs.

"JetBrains has always seen its mission as bringing the best of the industry to our users. I'm very excited about Cursor becoming a special guest in the family of ACP-compliant agents in JetBrains IDEs. In this setup, developers stay in control of their environment, while Cursor brings the powerful AI assistance that has earned it such popularity. This collaboration looks like a win for Cursor, for JetBrains, and most importantly for developers."

Aleksey Stukalov
Head of IDEs Division, JetBrains

Getting started

Install the Cursor ACP directly in the JetBrains AI chat, and authenticate with your existing Cursor account. The Cursor ACP is free for all users on paid plans. Learn more in the docs.

What's next

The Cursor ACP is a foundation for deeper integrations with JetBrains. We're excited to bring agentic coding capabilities to more developers.

Original source Report a problem

Release Highlights

This release introduces interactive UIs in agent chats, a way for teams to share private plugins, and improvements to core capabilities like Debug mode.

MCP Apps

MCP Apps support interactive user interfaces like charts from Amplitude, diagrams from Figma, and whiteboards from tldraw directly inside Cursor.

Team marketplaces for plugins

On Teams and Enterprise plans, Admins can now create team marketplaces to share private plugins internally. Go to the settings page to manage and distribute plugins with central governance and access controls.

Desktop Improvements (15)

Desktop Bug Fixes (10)

Web Improvements & Fixes (2)

Original source Report a problem

Bugbot Autofix updates

Agents are now tackling more ambitious tasks, generating thousands of lines of code, and controlling their own computers to demo their work. Today, we're extending these capabilities to Bugbot, our code review agent.

Bugbot can now find and automatically fix issues in PRs. Bugbot Autofix spawns cloud agents that work independently in their own virtual machines to test your software. Over 35% of Bugbot Autofix changes are merged into the base PR.

Autofix is now out of beta and available to all Bugbot users. Once enabled, the PRs Bugbot reviews will include proposed fixes to give you a jumpstart on code review.

Resolving more bugs per PR

We’ve continued to invest in Bugbot’s effectiveness at identifying issues while optimizing for bugs that get fixed.
The average number of issues identified per run has nearly doubled in the last six months, while the resolution rate (i.e., percentage of bugs resolved by users before the PR is merged) has increased from 52% to 76%. This means Bugbot is catching more bugs and flagging fewer false positives.

What's next

Bugbot Autofix is an early example of agents running automatically based on an event like PR creation. Next, we are working on giving teams the ability to configure custom automations for workflows beyond code review.
We’re also focused on enabling Bugbot to verify its own findings, conduct deep research on complex issues, and continuously scan your codebase to catch and resolve bugs.
Get started by enabling Bugbot Autofix in your Bugbot dashboard. Or learn more in our docs.

Original source Report a problem

When we started building Cursor a few years ago, most code was written one keystroke at a time. Tab autocomplete changed that and opened the first era of AI-assisted coding. Then agents arrived, and developers shifted to directing agents through synchronous prompt-and-response loops. That was the second era. Now a third era is arriving. It is defined by agents that can tackle larger tasks independently, over longer timescales, with less human direction. As a result, Cursor is no longer primarily about writing code. It is about helping developers build the factory that creates their software. This factory is made up of fleets of agents that they interact with as teammates: providing initial direction, equipping them with the tools to work independently, and reviewing their work. Many of us at Cursor are already working this way. More than one-third of the PRs we merge are now created by agents that run on their own computers in the cloud. A year from now, we think the vast majority of development work will be done by these kinds of agents.

From Tab to agents

Tab excelled at identifying where low-entropy, repetitive work could be automated. For nearly two years, it produced significant leverage. Then the models improved. Agents could hold more context, use more tools, and execute longer sequences of actions. Developer habits began to shift, slowly through the summer, then rapidly over the last few months with the releases of Opus 4.6, Codex 5.3, and Composer 1.5. The transformation has been so complete that today, most Cursor users never touch the tab key. In March 2025, we had roughly 2.5x as many Tab users as agent users. Now, that is flipped: we now have 2x as many agent users as Tab users.

Cloud agents and artifacts

Compared to Tab, synchronous agents work further up the stack. They handle tasks that require context and judgment, but still keep the developer in the loop at every step. But this form of real-time interaction, combined with the fact that synchronous agents compete for resources on the local machine, means it is only practical to work with a few at a time. Cloud agents remove both constraints. Each runs on its own virtual machine, allowing a developer to hand off a task and move on to something else. The agent works through it over hours, iterating and testing until it is confident in the output, and returns with something quickly reviewable: logs, video recordings, and live previews rather than diffs. This makes running agents in parallel practical, because artifacts and previews give you enough context to evaluate output without reconstructing each session from scratch. The human role shifts from guiding each line of code to defining the problem and setting review criteria.

The shift is underway inside Cursor

Thirty-five percent of the PRs we merge internally at Cursor are now created by agents operating autonomously in cloud VMs. We see the developers adopting this new way of working as characterized by three traits:

• Agents write almost 100% of their code.
• They spend their time breaking down problems, reviewing artifacts, and giving feedback.
• They spin up multiple agents simultaneously instead of handholding one to completion.

There is a lot of work left before this approach becomes standard in software development. At industrial scale, a flaky test or broken environment that a single developer can work around turns into a failure that interrupts every agent run. More broadly, we still need to make sure agents can operate as effectively as possible, with full access to tools and context they need. We think yesterday's launch of Cursor cloud agents is an initial but important step in that direction.

Original source Report a problem

Bugbot Autofix

Bugbot can automatically fix issues it finds in pull requests.

Autofix runs cloud agents on their own machines to test changes and propose fixes directly on your PR. Today, over 35% of Bugbot Autofix changes are merged into the base PR.

Bugbot will post a comment on the original PR with a preview of the autofix changes, which you can merge using the provided @cursor command. If you'd like, you can instead configure autofix to push changes directly to your branch with no interaction required.

To enable autofix, head over to your Bugbot dashboard.

Read more in our announcement.

Original source Report a problem