Cursor Security Review (2026): Code Review Bots, Pricing

On September 23, 2026, Cursor shipped two bots at once: Security Reviewer, which scans every pull request for exploitable vulnerabilities, and Rollouts, which follows a change past the merge and intervenes when it breaks in production. Overnight, "cursor code review" stopped being a one-bot story. Cursor's review stack is now three layers — BugBot for bugs, Security Review for vulnerabilities, Rollouts for production — each with its own bill.

The catch is who can buy it. Both new bots are gated to Teams and Enterprise plans ("Rollouts and Security Reviewer are available today on Teams and Enterprise plans"), and BugBot itself switched from a flat subscription to per-review usage billing in May 2026. So the practical questions are: what do these bots actually do, how do you turn them on, what does the whole stack cost now, and what are your options if the answer is "not on your plan." That's what this post covers.

Everything below is sourced to Cursor's announcement, its changelog entry, and the official docs for automations, security agents, and Bugbot pricing — where a page doesn't print a number, we say so instead of guessing.

Quick answer

• Security Review scans every PR for exploitable bugs — injection, broken auth, committed secrets, unsafe deserialization — and reports each finding with "a severity, an attack path, and a one-click fix."
• Rollouts watches the deploy, not just the diff. Per Cursor: "Rollouts watches a change from PR to production, flags regressions, and acts to restore a healthy state."
• Both bots are Teams/Enterprise only, enabled from the automations tab. They run as a shared team service account, so the usage bills to the team pool — no individual quota is touched.
• BugBot is the bugs-and-quality layer, and its meter changed. The old $40/month plan (up to 200 PRs/month) became usage-based billing with the May 2026 pricing update. Community estimates put a typical review around $1; Cursor's docs print no official rate card.
• Can't get the bots? CodeRabbit, Qodo's open-source PR-Agent, and cubic cover the same ground — and there's a genuine free route if you self-host PR-Agent on a cheap model. Comparison table below.

What Cursor Security Review actually does

Per the announcement, "Security Reviewer runs on every PR, reads the change in the context of the whole codebase," and checks 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"

The changelog's summary adds SSRF and auth bypasses to that list and notes the bot traces user-input flows through the change. What it deliberately does not cover is style: per the changelog, Security Review posts a single comment per PR focused on exploitable bugs, and style and quality remain Bugbot's job. One bot finds the mistake that breaks your app; the other finds the one that breaks your compliance review.

The output format is the part teams will feel: "Each finding has a severity, an attack path, and a one-click fix." In the security agents docs, severity filters run Critical, High, or Medium, and a Fix in Cursor action starts a Cloud Agent to produce the fix in the repository. Dismissed findings won't re-fire on the same PR, and draft PRs are skipped — the bot only reviews code you intend to merge.

Two mechanics worth knowing before you budget:

• Who it bills. The docs state the agents run "under a shared team service account, so they don't affect any individual user's usage" — findings cost the team pool, not anyone's plan.
• What it runs on. "Both agent types run on the Automations platform and require Cloud Agents." There's no local-only mode; this is a cloud product through and through.

Individual-plan users aren't entirely locked out of the idea: since Cursor 3.7, the /review-security skill runs a security pass over your changes pre-push, locally, from the editor or CLI. It's a manual command rather than a per-PR gate, but it's the same detection family without the plan requirement.

Cursor Rollouts: the bot that watches the deploy

Every review bot above checks code before it ships. Rollouts is Cursor's answer to the failure mode they all miss: the change that was fine in staging and on fire in production.

Cursor's one-line pitch: "Rollouts watches a change from PR to production, flags regressions, and acts to restore a healthy state." The mechanics, from the changelog and announcement:

• On PR open, Rollouts reads the diff and posts a monitoring plan as a PR comment — the risks, the intended effects, the signals worth watching, and the instrumentation gaps. You can edit the plan; the bot honors the edits.
• On deploy, it runs that plan against your logs, metrics, and traces, tracking each environment separately — which is how staging can pass while production gets flagged.
• On regression, "it tells you which change it suspects and what it plans to do." The escalation menu per the announcement: "that's a ping to the author, a paused progressive rollout, or a revert PR waiting for approval."

One honesty note that matters for anyone evaluating this as an SRE tool: Rollouts does not merge or roll back on its own today. The changelog is explicit. It prepares the revert PR and notifies the author; a human still pulls the trigger. That's the right default for 2026, but if your threat model is "nobody is awake at 3 a.m.," Rollouts is a watchman with a phone, not autopilot.

It also has the most infrastructure requirements of anything Cursor ships: it wants your source control (Origin or GitHub), a deploy/CD system to observe, and a telemetry source such as Datadog. If your deploys happen on a laptop with a git push, there is nothing for it to watch. Cursor ran a promotion at launch — roughly 10 days of credits covering ~50 changes on Teams and ~500 on Enterprise — so an evaluation costs little; after that it bills as cloud agent usage.

How to enable the bots: the automations tab

Both bots live on Cursor's automations platform — "Cursor Automations run cloud agents in the background, either on a schedule or in response to events from GitHub, GitLab, Slack, webhooks, Linear, and more," per the docs. BugBot, Security Review, and Rollouts are all configurable from the same place; the announcement's instruction is one line: "Enable either bot from the automations tab to get started."

The actual checklist:

1. Confirm your plan. The new bots require Teams or Enterprise; the automations dashboard is where they appear.
2. Connect source control — Origin or GitHub. For Rollouts, also connect your deploy system and a telemetry provider (Datadog and others).
3. Open the automations tab (or the Agents Window, or /automate from a session) and pick the bot: Security Reviewer, Rollouts, or BugBot.
4. Select repositories and toggle the built-in checks you want. One quirk from the docs: "A Security Reviewer needs at least one tool or MCP before you can save it" — wire a Slack channel or an issue tracker so findings have somewhere to go.
5. Save and activate. Triggers follow the standard automations model — pull request and merge request events for Security Review, deploy events for Rollouts.

Billing note: automations create cloud agents, and per the docs they're "billed based on cloud agent usage." The security bots run under the shared service account (team pool); a personal automation you build yourself under "Run as: Me" bills to you.

How BugBot billing works: from $40/month to per-review

BugBot is the layer most people already associate with cursor code review — it comments on PRs with bugs and fixes, and Cursor claims "70%+ of flags get resolved before merge." Its pricing is also the part with the most history, so here's the full chain:

• Before May 2026 (legacy): Bugbot was a flat subscription — "$40 per month for Bugbot reviews on up to 200 PRs per month across all repositories," per the legacy pricing doc; Teams paid $40 per user per month. Hit the cap and reviews paused until the next cycle.
• May 2026 pricing update: "Bugbot pricing changed with the May 2026 pricing update," and the current doc is blunt: "Bugbot uses usage-based billing." On Individual plans, "Bugbot first consumes your included usage, then bills additional reviews through on-demand spend." On Teams, "Bugbot Teams bills from on-demand spend."
• What does a review cost? Cursor's official pages don't print a per-review rate card. Community reporting and user posts around the switch put a typical review at roughly $1–1.50 (it's per review, not per PR — re-reviews on new commits bill again), and Bugbot's own analytics API example in the docs logs one review at 42.5 cents. Treat every per-review figure as an estimate that varies with PR size and effort level; the only official statement is "usage-based."
• Today's plans: the pricing page bundles Bugbot as "Bugbot on usage-based billing" on Individual ($20/month) and "Agentic code reviews with Bugbot" on Teams ($40/user/month). Cursor has historically offered a 14-day free trial, but the current pricing page doesn't print trial terms, so treat that as unconfirmed and check at signup.

The mental model after the switch: BugBot stopped being a seat you rent and became a meter you run. Light teams with a few PRs a week will likely pay less than $40; monorepos that re-review every commit can pay much more — which is exactly why the alternatives section below exists.

Cursor BugBot alternatives (including the free routes)

If you're priced out, plan-locked, or just comparison-shopping — this is the cursor bugbot alternative field, including the CodeRabbit matchup:

Cursor BugBot vs CodeRabbit, the matchup everyone searches: CodeRabbit is cheaper at team scale ($24 vs $40/user/mo plus per-review overages), prints its prices, and reviews public repos free forever — open-source maintainers basically get a no-cost BugBot. BugBot's edge is Cursor's own claim of a low false-positive rate and tight editor loop ("fixes delivered directly in your Cursor editor"), and it's included in a plan you might already pay for. If your team lives in Cursor Teams already, BugBot on usage is the path of least resistance; if you're on Individual plans or watching spend, CodeRabbit's flat per-dev price is easier to budget.

The actual free route is the bottom row: Qodo's PR-Agent is MIT-licensed and self-hostable, and wiring it to a cheap model like DeepSeek means your "code review bot" costs API tokens and a cron job. You give up polish — no polished dashboard, you own the bot — but nothing about it is plan-gated. (For a walkthrough of the human-side workflow, see our Copilot code review tutorial; the mechanics of reviewing AI-generated code carry over.)

Which setup do you actually need?

• Teams/Enterprise on Cursor, shipping daily → enable both new bots from the automations tab and let BugBot ride usage-based. This is the only configuration that gets the full three-layer stack.
• Individual plan ($20/mo) → the bots are plan-locked, so pick: BugBot on usage if your PR volume is low, CodeRabbit if you want flat pricing, or /review-security pre-push plus PR-Agent if you want zero marginal cost.
• Open-source maintainer → CodeRabbit on your public repo, free forever. Not close.
• Security-review-driven org → Cursor's Security Review is the most concrete productized offering here (severity, attack path, one-click fix per finding) — but it presumes Teams/Enterprise and cloud agents. Regulated shops that can't use cloud review should look at self-hosted PR-Agent behind their own firewall.
• Watching budget above all → self-hosted PR-Agent + DeepSeek tokens. The subscription-free ceiling is real.

For how these bots position Cursor against its closest competitor overall, see Devin Desktop vs Cursor — its code-review section covers the same September launch from the comparison angle.

FAQ

What is Cursor Security Review? It's a Cursor bot, launched September 23, 2026, that reviews every pull request for exploitable security bugs in full-codebase context — injection, missing or broken auth, committed secrets, unsafe deserialization, vulnerable dependency changes, insecure defaults. Each finding ships with a severity, an attack path, and a one-click fix. It requires Teams or Enterprise and is enabled from the automations tab.

How much does BugBot cost in 2026? BugBot moved to usage-based billing with the May 2026 pricing update, replacing the old $40/month plan (200 PRs/month). Reviews first consume your plan's included usage, then bill through on-demand spend. Cursor's docs don't print an official per-review rate; community estimates put typical reviews around $1–1.50 each. Cursor has historically offered a 14-day free trial, but the current pricing page doesn't print trial terms.

Is Security Review available on Cursor Pro or the Individual plan? No. "Rollouts and Security Reviewer are available today on Teams and Enterprise plans" — that's Cursor's own wording. Individual users keep BugBot on usage-based billing and can run the /review-security skill manually before pushing, but the per-PR security gate and Rollouts monitoring are Teams-and-up.

What's the difference between BugBot and Security Review? BugBot hunts logic bugs and code quality; Security Review hunts exploitable vulnerabilities and ignores style entirely. They're complementary layers on the same PR — per Cursor's changelog, Security Review posts one comment about exploitable bugs while "style/quality remains Bugbot's job." You can run both; you'll get two different comment threads.

Does Cursor Rollouts roll back a bad deploy automatically? Not on its own. The changelog states "Rollouts does not merge or roll back on its own today." On a regression it names the suspected change and escalates — a ping to the author, a paused progressive rollout, or a revert PR waiting for approval. A human approves the revert.

Cursor BugBot vs CodeRabbit — which should a small team pick? CodeRabbit for predictable costs: $24/developer/month billed annually, published prices, and free reviews forever on public repositories. BugBot if the team already runs Cursor Teams and values the low-false-positive claim plus in-editor fixes — but on usage-based billing, a repo that re-reviews every commit can outrun flat pricing fast. The genuinely free option is self-hosting Qodo's MIT-licensed PR-Agent against a cheap API model.

Related reading

• Devin Desktop vs Cursor — where the Rollouts and Security Review bots fit in the 2026 editor-vs-agent comparison
• Cursor projects tutorial — structure a repo so review bots have rules to enforce
• Use DeepSeek in Cursor — wire a cheap model into the editor your bots run from
• Copilot code review tutorial — the same review workflow on GitHub's stack
• Claude Code attribution — the same week's other AI-coding-governance story