What's New in Cursor: The Features Changing How You Code
Cursor has shipped more in the last three months than most IDEs ship in a year. If you haven't checked the changelog since late 2025, you're missing features that meaningfully change the daily development loop — not just cosmetic improvements.
This covers everything that landed between February and March 2026: Automations, Cloud Agents with Computer Use, Bugbot Autofix, MCP Apps, Team Marketplaces, and JetBrains ACP. Each section explains what it is, how to enable it, and when it's actually worth using.
Automations: Always-On Agents That Run Without You
Cursor Automations let you build agents that trigger on a schedule or on events from external tools — without you being present.
Trigger sources supported today:
- Cron schedules
- GitHub events (push, PR created, issue opened)
- Slack messages
- Linear issue updates
- PagerDuty alerts
- Webhooks (custom)
When a trigger fires, Cursor spins up a cloud sandbox, follows your instructions, uses whatever MCPs you've configured, and can optionally remember the outcome of previous runs to improve over time.
Real examples the Cursor team has shared:
Every morning, an automated agent reviews recently merged code, identifies areas without test coverage, follows your existing test conventions, and opens a PR with the new tests added. You wake up to coverage improvements already queued for review.
When a bug report lands in a Slack channel, an automation checks for duplicates, creates a Linear issue via MCP, investigates root cause in the codebase, attempts a fix, and posts a summary back in the original thread — all without a developer context-switching.
To set one up, go to cursor.com/automations or start from a template in the Marketplace. The Marketplace already has automation templates for common workflows including test coverage, triage, and daily standup summaries.
When to use Automations vs. running an agent manually: Use Automations for anything that should happen on a trigger or schedule without requiring a developer to initiate it. Keep manual agents for tasks that need human judgment on whether to run at all.
Cloud Agents with Computer Use
This one is hard to oversell. Cloud agents can now use the software they build to test their own changes.
Each cloud agent runs in an isolated VM with a full dev environment. After writing code, the agent can start the app, click through it, run the test suite, check that the feature actually works, and record video, screenshots, and logs as artifacts. The PR it opens includes those artifacts so reviewers can see exactly what the agent tested.
What this changes in practice:
Before this, you'd review an agent's PR and have no idea whether it ran the code. Now the PR itself tells you: here's the running app, here's a screen recording of the flow, here's the test output. Your review job is verifying intent, not re-running everything the agent already ran.
Cloud agents are available on web, desktop, mobile, Slack, and GitHub. To onboard a new repo, go to cursor.com/onboard — the agent configures its own environment and records a demo.
Important limit to know: cloud agents work best with well-structured, modern codebases. If you're pointing one at a legacy monolith with inconsistent conventions, expect more manual steering.
Bugbot Autofix: From Bug Reports to Merged Fixes
Bugbot graduated from reviewer to fixer in late February 2026.
Previously, Bugbot reviewed PRs and posted a list of issues it found. Now it goes further: when it finds a problem, it spins up a cloud agent on its own machine, tests a fix, and proposes the fix directly on your PR.
Over 35% of Bugbot Autofix suggestions are being merged into the base PR — a meaningful signal that the fixes are landing, not just piling up as noise.
How the workflow looks:
- You open a PR
- Bugbot reviews it and finds an issue
- Bugbot posts a comment with the proposed fix preview
- You merge it with the provided
@cursorcommand — or configure it to push directly to your branch with no interaction required
Autofix is now out of beta. Enable it in your Bugbot dashboard.
One note on quality: the Cursor team reports the resolution rate (bugs flagged by Bugbot that get fixed before merge) went from 52% to 76% over six months, while the average number of issues identified per run nearly doubled. The tool is getting more accurate, not just louder.
MCP Apps: Interactive UIs Inside Agent Chats (v2.6)
MCP Apps arrived in the v2.6 release on March 3. The feature lets MCP servers render interactive UI components directly inside Cursor's agent chat — not just text responses.
Supported UI types today:
- Charts and analytics dashboards (Amplitude MCP)
- Design diagrams and component specs (Figma MCP)
- Whiteboards and diagramming (tldraw MCP)
What this looks like in practice:
You ask an agent to analyze user engagement for a feature you're building. Instead of the agent describing numbers in a text block, the Amplitude MCP renders a live chart inline in the chat. You adjust the date range directly in the chart without leaving Cursor.
You ask an agent to implement a UI component. The Figma MCP renders the design spec beside the code diff. No tab-switching.
MCP Apps are only useful if the MCP server you're using has implemented UI support. Check the Cursor Marketplace for which servers currently support it — Amplitude, Figma, and tldraw are the three notable ones at launch.
Team Marketplaces for Plugins (v2.6)
Also in v2.6: Teams and Enterprise plan admins can now create a private plugin marketplace for their organization.
This solves a real governance problem. If you've been on a larger team using Cursor, you've probably seen the "everyone installs plugins however they want" situation. Team Marketplaces give admins:
- A central place to publish and version internal plugins
- Access controls over which teams can install which plugins
- The ability to enforce which plugins are available without individual config
Set it up under Settings → Plugins → Team Marketplace. From there you can publish plugins from your org's GitHub or upload them directly.
Cursor in JetBrains IDEs: ACP Integration
As of March 4, Cursor is available inside IntelliJ IDEA, PyCharm, WebStorm, and other JetBrains IDEs through the Agent Client Protocol.
This matters for a specific group: developers who can't or won't leave JetBrains — particularly Java and Kotlin teams — but want access to Cursor's agent capabilities and model selection.
What ACP gives you inside JetBrains:
- Agent-driven development using models from OpenAI, Anthropic, Google, and Cursor's own models
- Authentication with your existing Cursor account
- The same frontier model access you'd have in Cursor desktop
What it doesn't give you:
- The full Cursor IDE experience (Tab autocomplete, Composer, codebase indexing)
- It's an agent client inside an existing editor, not a replacement IDE
ACP is free for all paid Cursor plans. Install it from the ACP Registry directly in the JetBrains AI chat panel.
Parallel Agents and Composer 1.5 (v2.5, Feb 17)
A quick recap of what landed in v2.5 since it set the foundation for the March releases.
Cursor 2.5 introduced long-running cloud agents that run in parallel — up to eight at once in isolated Ubuntu VMs with Git worktrees keeping code changes separate. Most tasks complete in under 30 seconds. Agents can open PRs and run self-tests via a native browser tool.
Composer 1.5 ships with this version and triples the usage limit of Composer 1. Through mid-February, that limit was temporarily bumped to 6x.
The usage model also split into two pools: Auto + Composer (high limits) and Fast Premium (smaller pool for the most capable models). This means you can run agents more freely day-to-day without burning through your budget on routine tasks.
What's Coming Next
The Cursor team has signaled a few directions without publishing a formal roadmap:
Custom automations beyond code review. The Bugbot Autofix architecture — event-triggered agents with their own sandboxes — is being extended so teams can define custom automations for any workflow, not just PR review.
Bugbot self-verification. The next step is having Bugbot verify its own findings before posting them, which should reduce false positives further and allow continuous codebase scanning, not just PR-triggered scans.
Deeper JetBrains integration. The ACP launch is described as "a foundation" — expect more JetBrains-specific capabilities beyond the current agent client.
Summary
- Automations (Mar 5): schedule- and event-triggered agents that run without you present — set up at cursor.com/automations
- Cloud Agents with Computer Use (Feb 24): agents that test their own code, record demos, and open PRs with artifacts
- Bugbot Autofix (Feb 26): agents that propose and push fixes to your PRs, not just flag problems
- MCP Apps (v2.6, Mar 3): interactive charts, diagrams, and whiteboards rendered inside agent chats
- Team Marketplaces (v2.6, Mar 3): centralized plugin governance for Teams and Enterprise
- JetBrains ACP (Mar 4): Cursor agents inside IntelliJ, PyCharm, and WebStorm
- v2.5 Parallel Agents + Composer 1.5 (Feb 17): foundation for everything above
The through-line across all of these: Cursor is moving from "AI helps you write code" to "AI runs workflows you define." The manual-agent model is still there, but the platform is clearly being built for teams that want AI running on their codebase 24/7.
Tested and verified against the official Cursor changelog as of March 9, 2026