--- title: "Cursor's Bugbot Catches 10% More Bugs and Runs 3x Faster" subtitle: "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" url: "https://alphasignal.ai/news/cursor-s-bugbot-catches-10-more-bugs-and-runs-3x-faster" author: "AlphaSignal Newsroom" author_url: "https://alphasignal.ai/editorial-team" company: "Cursor" company_url: "https://alphasignal.ai/company/cursor_ai" published: "2026-06-10T18:20:18.000Z" updated: "2026-06-10T18:37:46.201Z" type: "News" topics: - "Development" - "Business" subtopics: - "Code Review" - "Code Agents" upvotes: 2467 read_time: "5 min" source_url: "https://cursor.com/blog/bugbot-updates-june-2026" comments: 0 --- # 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 [Bugbot](https://cursor.com/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. ![Performance comparison chart showing Bugbot median run time dropping from 5 min to 1.5 min, and 90th percentile dropping from 9 min to 3 min](https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/changelog/bugbot-performance.png) ## 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." ![Comparison table showing Bugbot performance improvements: runtime, bugs found per run, and cost per run before and after](https://ptht05hbb1ssoooe.public.blob.vercel-storage.com/assets/blog/bugbot-performance-table.png) ## 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 `/review` sync, so check the [docs](https://cursor.com/docs/bugbot) 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](https://cursor.com/dashboard/bugbot). Pricing starts at $40/user/month as part of the Cursor Teams plan, which includes a 14-day free trial. ## Sources - [X post by @cursor_ai](https://x.com/cursor_ai/status/2064774675021119825) - [Bugbot is now over 3x faster, 22% cheaper, and finds 10% more bugs · Cursor](https://cursor.com/blog/bugbot-updates-june-2026) - [AI Code Review Built for Production | Bugbot by Cursor](https://cursor.com/bugbot) - [Using Cursor Bugbot to autoreview and fix Claude Code PRs — WorkOS](https://workos.com/blog/cursor-bugbot-autoreview-claude-code-prs) - [Bugbot now self-improves with learned rules · Cursor](https://cursor.com/blog/bugbot-learning) - [Cursor BugBot Review (2026) | ACR](https://aicodereview.cc/tool/cursor-bugbot/)