The Plugin Marketplace That Changes How You Work With Your Whole Stack

Cursor 2.5 dropped on February 17, 2026, and the headline feature is something developers have been quietly wanting for a while: a proper plugin marketplace that connects your coding environment directly to the tools you're already using — Figma, Stripe, AWS, Linear, Vercel, and more without the usual setup headache.

But there's more in this release than just the marketplace. Async subagents got a meaningful upgrade, Composer 1.5 usage limits expanded significantly, and Bugbot , Cursor's automated code review tool has quietly become genuinely reliable. Here's what's actually changed and what it means for your day-to-day work.

The Marketplace: One Install, Everything Wired Up

The biggest shift in 2.5 is the Cursor Marketplace at cursor.com/marketplace. The idea is straightforward: instead of manually configuring connections between Cursor's AI agent and the tools you use, you install a plugin and everything — the connection to the tool's API, the agent's knowledge of how that tool works, and the right instructions for using it — comes pre-bundled.

Each plugin is a package containing some combination of:

• An MCP server (Model Context Protocol, essentially the live connection that lets the agent talk to an external tool or API in real time)

• Skills — pre-written instructions that teach the agent the right way to work with that tool

• Subagents — specialist agents that handle specific tasks within that tool's context

• Hooks — scripts that trigger automatically at certain points in the agent's workflow

• Rules — guardrails that keep the agent consistent with your project's conventions

The practical effect is that setup that used to take meaningful configuration effort now takes a single click.

Launch partners cover a solid spread of the typical developer workflow: Figma for design handoff, Stripe for payments, AWS for infrastructure, Vercel for deployment, Linear for issue tracking, Amplitude for analytics, Cloudflare, Databricks, Snowflake, and Hex for data work. You can install them via /add-plugin inside the editor, or browse cursor.com/marketplace and click "Add to Cursor."

The early feedback from developers who've tested it is encouraging. A senior engineer at Stripe described the Stripe plugin as teaching Cursor "how Stripe integrations should be built", it created products, prices, and payment links using Stripe's API and shipped a working payment flow almost immediately. The Figma plugin lets the agent pull in design files, read component specifications, and generate code that matches the actual design rather than approximating it. A product manager at Amplitude noted that the plugin can pull in user behaviour data, analyse growth dashboards, and draft a pull request all in one instruction.

The community submission system is also open now. You can build your own plugin and publish it at cursor.com/marketplace/publish. Cursor has published their own internal workflows (called the Cursor Team Kit) as a starting point. It includes their CI, code review, and testing procedures, which gives you a useful template for encoding your own team's practices.

One thing still in progress: private team marketplaces. The ability to share plugins internally with security controls and central governance is confirmed as in active development, but no release date has been announced as of February 2026. For teams with security or compliance requirements, that's worth tracking.

Async Subagents: Parallel Work That Actually Runs in Parallel

Subagents — the specialist agents Cursor can spin up to handle discrete chunks of a task — have been in Cursor for a while. The problem was they ran synchronously, meaning the main agent had to wait for each subagent to finish before moving on. In a complex task, that queuing added up.

In 2.5, subagents run asynchronously. The parent agent kicks off a subagent, then keeps working on its own tasks while the subagent runs in the background. Subagents can also now spawn their own sub-subagents, creating a coordinated tree of parallel work.

The practical difference for a developer: if you're doing a large refactor that involves updating API schemas, running tests, and checking for deprecated dependencies, those three workstreams no longer wait for each other. One developer described sending a legacy Node module off to subagents to handle dependency hunting while going to make coffee, coming back to it finished. That's the kind of friction that disappears.

The update also delivers lower latency and better streaming feedback, so you see progress rather than a spinning indicator.

Composer 1.5: More Usage, Better Value

Cursor's own coding model ( Composer ) got a usage limit expansion in this release. Composer 1.5 now has 3x the usage limit of the original Composer 1, with a temporary 6x increase running through mid-February 2026.

In benchmark testing (Terminal-Bench 2.0, an agent evaluation benchmark for terminal use), Composer 1.5 scores above Anthropic's Claude Sonnet 4.5 on coding tasks, though below the top frontier models. For most everyday coding work, refactors, test writing, endpoint creation the quality is in the right range, and the speed is meaningfully faster than using external models.

Real-world time savings reported by developers using Cursor with Composer:

• Creating CRUD endpoints (the standard add/read/update/delete data operations): from 1.5 hours down to 35 minutes

• Adding TypeScript types to an existing untyped codebase: 2 hours down to 40 minutes

• Writing unit tests: 1 hour down to 25 minutes

These are from a developer who tracked their time over three months of daily use, not a marketing benchmark.

The usage pool is now split into two: Auto + Composer credits, and API credits for when you're using external models like Claude or GPT-4. Both reset with your monthly billing cycle.

Bugbot: Finally Worth Relying On

Bugbot — Cursor's automated code review agent that runs on pull requests (the process of submitting code changes for review before they're merged into the main codebase) — has been steadily improving since it launched in mid-2025, and the numbers are now meaningful.

Since launch, Cursor ran 40 major experiments on Bugbot's quality. The bug resolution rate went from 52% to over 70%. The average number of bugs flagged per pull request went from 0.4 to 0.7. The number of bugs actually fixed per pull request has more than doubled. Critically, this happened without a comparable rise in false positives — Bugbot isn't just flagging more, it's flagging more of the right things.

The metric Cursor uses to measure the "resolution rate", tracks whether bugs flagged by Bugbot were actually fixed by the engineer before the code was merged. It's a more honest measure than simply counting how many issues get raised.

For teams doing code review, Bugbot is now at a level where it's worth including in your review workflow rather than treating as a nice-to-have.

What's Still Worth Knowing

A few things to keep in mind before you dive in:

Cursor is built on VS Code 1.92 as of February 2026. The current VS Code is on version 1.95. New editor features from VS Code typically take one to two months to appear in Cursor — not a dealbreaker, but worth knowing if you're tracking specific editor updates.

Code privacy remains a consideration. Your code is sent to AI providers for processing. Cursor says they don't train models on your data, but if you're working on confidential or sensitive projects, it's a factor to weigh.

Performance on very large codebases can still be inconsistent. Multiple reviewers noted that the editor can lag or freeze on repositories with significant scale. The codebase indexing improvements in recent releases help (at the 99th percentile, indexing time dropped from over four hours to 21 seconds), but it's not uniform.

Pricing moved to a credit-based system in mid-2025, which caused frustration in the community. The current plans run from around USD $15–20/month for Pro depending on the plan, with Pro Plus and Ultra tiers above that. The expanded Composer 1.5 usage limits improve the value proposition noticeably.

Where to Start With 2.5

If you're already on Cursor, here's what's worth doing first:

1. Update to 2.5 if you haven't already — the marketplace is the main reason, but the async subagent improvements alone are worth it

2. Install one plugin for the tool you use most — Figma if you're doing frontend work, Stripe if you're building payment flows, Linear if you're working off a ticket board

3. Try the Cursor Team Kit — it's Cursor's own internal workflow for CI, code review, and testing. Even if you only take pieces of it, it's a useful reference for building your own team's plugin

4. If you're on a team, keep an eye on the private marketplace announcement — no date yet, but it's the feature that will make plugin-based workflows practical at an organisation level

The 2.5 release doesn't reinvent Cursor. What it does is close a gap that's been there since the agent features launched: the tools your agent can use have been limited to what you've configured manually. The marketplace makes that extensible in a way that scales. That's genuinely useful, and the early developer response reflects it.