Cursor's Bugbot Catches 10% More Bugs and Runs 3x Faster
Cursor's Bugbot code review agent gets a major upgrade: 3x faster, 22% cheaper, and a new /review command to catch bugs before you push
- 3x faster, 22% cheaper: Bugbot's median review time drops from 5 min to 90 sec; 90% of runs finish under 3 min.
- New /review command: Run Bugbot locally before pushing; available in Cursor 3.7+ and cursor.com/agents.
- 10% more bugs found: Bugs found per run rises from 0.56 to 0.62, powered by the new Composer 2.5 model.
- Incremental PR reviews: Bugbot can now be configured to only review new changes since the last review, reducing noise.
- Smart dedup: If you run /review locally and open a PR with the same diff, Bugbot skips the cloud review automatically.
- Resolution rate near 80%: Up from 52% at launch, 15 points ahead of the next-closest AI code review tool.
Bugbot, Cursor's automated code review agent, just got its biggest performance upgrade yet. The agent now runs in a median of 90 seconds, down from 5 minutes, costs 22% less per review, and surfaces 10% more bugs per run. For teams living inside GitHub pull request workflows, this is the kind of compounding improvement that quietly changes how fast code ships.

The numbers in full
The headline metrics are clean and measurable. Here is what changed across the three key dimensions:
| Metric | Before | After | Change |
|---|---|---|---|
| Average runtime | 5 min | 90 sec | 3x faster |
| Bugs found per run | 0.56 | 0.62 | +10% |
| Cost per run | $1.00-$1.50 | <$1.00 | -22% average |
In practice, 90% of Bugbot runs now finish in under three minutes. That is a meaningful shift for teams that were previously waiting on reviews before merging.
What is powering the gains
These performance gains are made possible by harness improvements and progress Cursor has made training Composer 2.5, which now powers Bugbot. Composer 2.5 is Cursor's in-house model, purpose-built for agentic coding tasks, and this is the first time it has been directly wired into the Bugbot review pipeline.
Bugbot uses a combination of frontier and in-house models to review code. The shift to Composer 2.5 as the primary driver is what unlocks both the speed and the improved detection rate simultaneously -- a combination that is harder to achieve than it sounds, since faster inference often comes at the cost of quality.
Bugbot respects model block lists. If your organization has opted out of Composer 2.5, Bugbot will automatically fall back to the next best available model, and speed and performance can vary depending on your configuration.
Run a review before you even push
The most practically useful new feature is the /review command, which lets you trigger Bugbot locally inside Cursor before opening a PR. You can run Bugbot and Security Review with /review before pushing code. /review prompts you to choose which agents to run, or you can use /review-bugbot and /review-security directly.
There is also a smart deduplication behavior baked in. /review syncs with Bugbot on GitHub and GitLab. If you run /review and then open a PR with the same diff, Bugbot recognizes it, skips the review, and leaves a comment noting it has already reviewed that diff. No double-billing, no redundant noise in the PR.
The feature is available in Cursor 3.7+ and on cursor.com/agents, with support in CLI coming soon.
Incremental reviews, not full reruns
A long-standing pain point with automated review tools is that they re-review the entire PR on every push, which means previously-approved code can get re-flagged. Cursor is now fixing this. You can now configure Bugbot to only review what's new since the last review, keeping feedback focused on your latest updates. This is a small quality-of-life change that meaningfully reduces noise for iterative PRs.
Where Bugbot fits in your workflow
Unlike general-purpose code review tools that flag everything from style violations to potential bugs, Bugbot takes a deliberately narrow and opinionated approach: it focuses exclusively on catching real bugs -- logic errors, security vulnerabilities, race conditions, null pointer dereferences, edge cases, and incorrect error handling -- while intentionally ignoring formatting, style, and low-severity concerns.
The signal-to-noise ratio is what makes it practical. Over 70% of flags get resolved before merge. That resolution rate is the key metric Cursor optimizes for -- it is a proxy for whether the flags are actually useful, not just technically correct.
One emerging use case is pairing Bugbot with AI-generated code. Different AI models catch different mistakes, which is why running Cursor Bugbot on every Claude Code PR makes sense -- you should have different AI models review each other's code, not the same model that wrote it. Bugbot is described as "incredibly strong at reviewing AI-generated code."

What it is not great at
- Bugbot deliberately avoids commenting on style, formatting, or low-severity concerns -- which is by design, but means it will not replace a thorough human review for architectural decisions.
- Bugbot only works with GitHub. There is no GitLab or Bitbucket support. (Note: the official blog mentions GitLab support for
/reviewsync, so check the docs for the latest.) - Performance varies if your org has blocked Composer 2.5 -- the fallback model will not match the new speed or detection benchmarks.
The bigger picture
When Bugbot launched out of beta in July 2025, 52% of the bugs it identified were resolved by the time the relevant PR was merged. Today, the resolution rate is nearing 80%, 15 percentage points higher than the next-closest AI code review product. That trajectory -- from a coin-flip to a genuinely reliable signal -- is what makes this update more than a performance patch.
Cursor has enabled Bugbot to learn from past runs, transforming feedback from the live code review process into learned rules. Rules act as additional instructions that enable greater customization of Bugbot runs, helping Bugbot focus on specific issues, business context, and more. Combined with the new speed and the /review command, the system is now fast enough and accurate enough to sit in the critical path of a real shipping workflow -- not just as a background safety net, but as a first-pass reviewer you actually trust.
Bugbot is available now. You can enable it from the Cursor dashboard. Pricing starts at $40/user/month as part of the Cursor Teams plan, which includes a 14-day free trial.