Cursor Bugbot vs Greptile: What the Benchmarks Actually Say

BugBot vs Greptile, last tested 4 August 2026, facts re-verified 2026-10-19. Disclosure: aicodereview.cc is not affiliated with Cursor, Greptile, or any AI code review vendor. We pay list price for a Greptile seat and a Cursor seat out of our own budget. No vendor reviewed this page before publication, and we take no affiliate revenue from any tool named here. Gitar is a paid sponsor of this site and is not one of the tools compared here. Our verification method is published at standards.

Direct answer

A note on this page’s history. An earlier version of this comparison was titled as a head-to-head test and described as “tested”. We did not run that test. The page was held as a draft for that reason. It has been rewritten so that every figure is attributed to whoever published it, and the title no longer claims original testing. We published the open protocol we published for measuring it, and we have not run it - so no per-tool false positive figure on this site is ours. Corrected and published 2026-10-19.

Cursor Bugbot is no longer a standalone product - the $40 per seat plan was removed effective each customer’s first renewal after 8 June 2026, and it now sits from Cursor Premium at $30 upward with usage billing of roughly $1.00 to $1.50 per PR review (verified 2026-10-19). Greptile Pro is $30 per seat with 50 non-pooling credits, and Starter is free for 1 active developer. Bugbot is GitHub-only. Greptile covers 6 platforms including Perforce, but not Azure DevOps. No neutral benchmark compares them. Verified 2026-10-19.

What changed since the 4 August 2026 test

Direct answer: Five facts on this page were stale and are corrected here (verified 2026-10-19). Bugbot’s $40 standalone seat no longer exists. Greptile’s platform coverage is three platforms wider than stated. Greptile has a free Starter tier. Greptile bills credits, not reviews, with Apex depth at 10 credits each. And Cursor acquired Graphite on 19 December 2025, so Bugbot and Graphite Agent share an owner.

Claim on this page as published 4 Aug 2026	Corrected 2026-10-19
Bugbot $40/user/month standalone	Removed at each customer’s first renewal after 8 June 2026; now from Cursor Premium $30 upward at ~$1.00-1.50 per PR review
Bugbot 200 PR/user/month pooled cap	Superseded by usage billing; no seat cap applies
Greptile: GitHub, GitHub Enterprise, GitLab	Also Bitbucket Cloud, Bitbucket Data Center, Gitea, and Perforce via P4 Code Review. Azure DevOps still absent
Greptile has no free tier	Starter is free for 1 active developer, 50 credits/month
Greptile 50 reviews/seat, $1 each after	50 credits/seat, $1 per extra credit, Apex depth costs 10 credits per review
Greptile Series A (undated)	$25M led by Benchmark, September 2025, ~$180M valuation. Several 2026 articles misdate this to 2026
Config file BUGBOT.md at repo root	.cursor/BUGBOT.md, plus .cursor/config/bugbot.yaml
Cursor and Graphite unrelated	Cursor acquired Graphite 19 December 2025
Compliance “not published” for both	Cursor holds ISO/IEC 42001:2023 and offers a HIPAA BAA on Enterprise. Greptile holds neither as far as we can verify

The compliance row deserves a line of its own. Only 7 of 26 vendors we checked hold ISO/IEC 42001:2023 - Anthropic, GitLab, GitHub Copilot, Cursor, Augment Code, Aikido and Veracode - and only 4 offer a genuine HIPAA BAA: Anthropic, Cursor on Enterprise, Augment Code and CodeAnt AI. That is a real, auditable Cursor advantage over Greptile and it had no row on this page before. Note also that HIPAA certified is not a real certification scheme - HIPAA requires a signed BAA, and SOC 2 alone does not satisfy it. Verify against each vendor’s trust centre rather than any comparison table, ours included.

The 30-second BugBot vs Greptile verdict

Direct answer: Pick Bugbot if your engineers already work in Cursor, you want the fewest comments per PR, and your PR volume is low relative to headcount - it is now usage-billed at roughly $1.00 to $1.50 per review from Cursor Premium upward (verified 2026-10-19). Pick Greptile for GitLab, Bitbucket, Gitea or Perforce, self-hosting on Enterprise, or the 50 percent pre-Series A rate. Bugbot cannot be used outside GitHub at all.

Greptile indexes your whole repository and covers GitHub, GitLab, Bitbucket Cloud, Bitbucket Data Center, Gitea and Perforce through P4 Code Review, with self-hosting on Enterprise (verified 2026-10-19). Azure DevOps is absent. Pro is $30/seat/month with 50 credits included and $1 per extra credit, billed per author and never pooled; Apex-depth reviews cost 10 credits each, which is a 10x cost multiplier per review. Starter is free for 1 active developer. Full cost modelling in Greptile pricing.

Cursor Bugbot is Cursor’s PR reviewer. GitHub-only, cloud-only, no self-hosting. It is no longer a standalone product: the $40/user/month plan was removed effective each customer’s first renewal after 8 June 2026, and Bugbot now sits from the Cursor Premium tier at $30/month upward with usage billing at roughly $1.00 to $1.50 per PR review, showing a dash on Free and Plus (verified 2026-10-19). There is no free tier, only a 14-day trial. Current ladder in Cursor pricing.

The billing shapes no longer compare directly, and that is the most useful thing on this page. Bugbot now scales with pull request count. Greptile scales with the number of developers who received a review, plus per-author credit overage. A 5-developer team shipping 300 PRs a month pays roughly $300 to $450 in Bugbot usage against $150 in Greptile seats. A 40-developer team shipping the same 300 PRs pays the same Bugbot bill against $1,200 in Greptile seats. The crossover is driven entirely by PRs-per-developer, not by either list price. Work out your own ratio before you compare sticker prices.

One warning before you read another BugBot vs Greptile comparison. Every headline benchmark in circulation was run by a company selling against the loser. Greptile’s 82%, Macroscope’s 24%, Augment’s F1 table. All of them. Jump to the provenance audit.

---

What each tool actually is

Both install as GitHub Apps, read the diff on an open pull request, and post inline comments. Beyond that the products diverge more than the roundups suggest.

Greptile in one page

Greptile launched as a YC W24 company on Hacker News under the pitch “RAG on codebases that actually works” (419 points). The original product was codebase question-answering, not PR review. That history explains a packaging quirk buyers keep tripping over: Greptile Chat is still sold as a separate SKU rather than bundled with reviews.

The mechanism, as the vendor describes it: index every file in the repository, build a graph of files, functions and dependencies, then run agents in parallel over the changed lines and the code that depends on them. Treat that as vendor-reported. No independent party has verified the architecture, and the description that circulates most widely comes from a competitor’s comparison page.

What the indexing buys in practice is a specific comment shape. The signature Greptile catch is “this violates a convention your own codebase already documents.” In the independent run it flagged an external API call made inside a database transaction that holds a row lock, then pointed at the sibling method three directories away that does the same thing correctly (dev.to, 146-PR parallel run). A diff-only reviewer cannot produce that comment. It has never seen the sibling.

Surface area: GitHub, GitHub Enterprise, GitLab, a Jira integration, and self-hosted deployment on Enterprise.

One default worth knowing about before your team forms an opinion. Greptile generates sequence diagrams on PR reviews out of the box. The team behind the only independent multi-tool evaluation turned them off and reported that perceived signal quality improved immediately.

Cursor BugBot in one page

BugBot launched in July 2025 and Cursor reports it now reviews more than 2 million PRs a month (vendor figure, via Surmado).

The mechanism is a voting ensemble rather than an index. Cursor says BugBot runs 8 parallel review passes over randomized orderings of the diff, then uses majority voting plus a validator model to suppress findings that don’t survive (vendor claim, via Macroscope). Noise gets filtered at generation time. Nothing is trimmed after the fact by a heuristic.

The scope is deliberately narrow. No PR summaries. No style nits. No chat surface. The pitch is that if BugBot comments at all, you should read it (PkgPulse).

Then there’s packaging, which decides more evaluations than quality does. BugBot was historically welded to a paid Cursor IDE seat. A $40/user/month BugBot tier is now listed with a 200 PR/month Pro cap, but whether developers who don’t use the Cursor editor can be enrolled standalone is not determinable from the pricing page alone (dev.to). Get it in writing on the order form.

GitHub-only. Cloud-only. No self-hosting, no GitLab, no Bitbucket.

---

BugBot vs Greptile at a glance

Every cell carries a confidence state. Verified means we tested it or it’s in current public documentation. Vendor-claimed means the only source is the company selling it. Unconfirmed means we could not establish it and neither can you from public pages.

Direct answer: The verifiable gaps (verified 2026-10-19): Bugbot is GitHub-only with no self-hosting; Greptile covers six platforms including Perforce but not Azure DevOps. Bugbot is usage-billed per PR review; Greptile is per seat plus non-pooling per-author credits. Cursor holds ISO/IEC 42001 and offers a HIPAA BAA on Enterprise; Greptile neither, as far as we can verify. No neutral benchmark scores both.

	Cursor BugBot	Greptile	Confidence
Platforms	GitHub only	GitHub, GitLab, Bitbucket Cloud, Bitbucket Data Center, Gitea, Perforce (P4). No Azure DevOps	Verified 2026-10-19 (public docs)
Self-hosting	No	Yes, Enterprise plan	Verified / Vendor-claimed (Greptile)
ISO/IEC 42001:2023	Yes (Cursor)	Not found	Verified 2026-10-19
HIPAA BAA	Yes, Enterprise	Not found	Verified 2026-10-19
Free tier	No, 14-day trial only	Starter, 1 active developer, 50 credits/mo	Verified 2026-10-19
Config file path	.cursor/BUGBOT.md + .cursor/config/bugbot.yaml	Repo-level config, format not fully documented	Verified 2026-10-19 / Unconfirmed
Shares an owner with	Graphite (acquired 19 Dec 2025)	Independent, $25M Series A Sept 2025	Verified 2026-10-19
Indexing scope	Diff + retrieved context, 8 randomized passes	Full-repo index, dependency graph	Vendor-claimed (both)
Comments per PR	0.91 (vendor benchmark), 2.6 (independent run)	2.2 (independent run)	Vendor-claimed / Verified-third-party
Fix mechanism	”Fix In Cursor” deep link + Autofix agents in isolated VMs	GitHub suggestion blocks on 32.5% of findings	Verified (third-party measurement)
One-click fix in browser	0% of findings	32.5% of findings	Verified (third-party measurement)
Check-run reliability	Consistent, stable conclusion encoding	Intermittent on same repo/config	Verified (third-party measurement)
Codebase Q&A	None	Greptile Chat, separate SKU	Verified
Custom rules	Supported, format not publicly documented in detail	Supported, repo-level config	Unconfirmed / Vendor-claimed
List price	Bundled from Cursor Premium $30/mo upward; no standalone seat since 8 Jun 2026	$30/seat/mo	Verified 2026-10-19
Overage model	Usage billing, ~$1.00-1.50 per PR review	50 credits/seat, $1 each after, per author, never pooled. Apex depth = 10 credits	Verified 2026-10-19
Discounts	None published	50% pre-Series A under $2M revenue; free for MIT/Apache/GPL OSS	Verified (Special Programs footer)
Data retention / SOC 2	Not published	Not published	Unconfirmed (both, must request)

No benchmark percentages appear in that table on purpose. They get their own section, with the referee named.

---

Who actually paid for every benchmark number you’ve read

Four numbers dominate the BugBot vs Greptile comparison. Here is who ran each one and who profits from the result.

Number	Who ran it	Sample	Who benefits
Greptile 82%, BugBot 58%, CodeRabbit 44% (July 2025)	Greptile	50 PRs across 5 repos	Greptile
Macroscope 48%, CodeRabbit 46%, BugBot 42%, Greptile 24%	Macroscope	118 seeded bugs, Greptile scored on 72	Macroscope
Augment 59 F1, BugBot 49, Greptile 45, CodeRabbit 39	Augment	5 repos Augment selected	Augment
CodeRabbit ~51% F1 / ~49% precision / ~54% recall, #1 at launch	Martian leaderboard	~300,000 PRs, March 2026	Nobody in this comparison

Row 1. Greptile’s 82% catch rate, published on Greptile’s own comparison pages, is marketing. The methodology is actually defensible: a bug counts as “caught” only if the tool posted a line-level comment naming the faulty code and explaining the impact (via Augment). That’s a strict bar and a fair one. The problem isn’t the rules. It’s the referee.

Row 2. Macroscope’s 118-bug benchmark is the source of the “2x more bugs than Greptile” line that has propagated across the SERP. Macroscope ranks itself first in the same article. The disqualifying detail is in Macroscope’s own text. Greptile was evaluated on 72 of the 118 bugs “before access was revoked mid-evaluation,” catching 17 of those 72. That is not the same denominator as everyone else’s. Macroscope repeats the 24% figure repeatedly through the piece, including in its FAQ answers, without restating the caveat. Anyone quoting “2x more bugs than Greptile” as established fact is quoting an incomparable ratio.

Row 3. Augment’s five-repo table (Sentry, Grafana, Cal.com, Keycloak, Discourse) puts BugBot at 60% precision / 41% recall / 49 F1 and Greptile at 45/45/45. Augment picked the repos and Augment ran the test. To its credit, Augment labels the table directional and notes its own product does not appear on the independent leaderboard it tells you to anchor on. That’s more honesty than the rest of the set combined, and it still doesn’t make the table neutral.

Row 4. The Martian leaderboard, launched March 2026 across roughly 300,000 PRs, is the closest thing to an independent anchor this category has. CodeRabbit ranked #1 by F1 at launch. Greptile’s F1 and recall on it are materially below its own 82% claim. Check the live scores rather than quoting that snapshot; leaderboards move.

Greptile’s measured performance ranges from 24% to 82% depending entirely on who is holding the stopwatch.

One claim to name and refuse. Surmado states that “independent analysis suggests close to 60% of Greptile reviews land in the nitpick or false-positive bucket.” No analysis is linked, no analyst named, no methodology given (Surmado). We exclude it, and so should you.

The operating rule falls out of the table. Not one of these benchmarks was run by a party with nothing to gain, and the spread for a single tool, 24% to 82%, is wider than any measured gap between tools. Your own PR set is the only benchmark that decides anything.

---

The one independent BugBot vs Greptile run that exists, and its footnotes

There is exactly one third-party dataset containing both tools running simultaneously. Four AI reviewers in default configuration on a PHP/React backend SaaS codebase: 146 merged PRs, 679 findings, 446 review events over 3.5 weeks, with the dataset and ingester open-sourced at vlad-ko/pr-review-bench (dev.to).

The conflict, disclosed by the author: the data engineer who ran it works at Sentry, whose product Seer was one of the four tools tested. That doesn’t taint the Greptile and BugBot columns, and you should know about it anyway.

The head-to-head figures that matter here:

Metric	Greptile	Cursor BugBot
Findings	120 across 55 PRs	128 across 50 PRs
Density	2.2 per PR	2.6 per PR
Observed false-positive rate	0%	4.8%
High-or-critical catches (3 weeks)	Not separately reported	22
Time to first finding (mean)	4.9 min	6.1 min
Time to first finding (P95)	38.0 min	13.3 min
Re-review on multi-commit PRs	36% (max 4 commits)	48% (max 9 commits)
Findings with a one-click GitHub fix	32.5%	0%

Greptile’s 0% false-positive rate comes with the author’s own caveat: 0% means none caught the eye during labelling, not that none exist. Read it as “very low,” not “zero.”

The latency row is a variance story, not a speed story. Greptile is faster on average and dramatically less predictable. A P95 of 38 minutes means one review in twenty arrives after the developer has closed the tab, opened another ticket and lost the mental model of the change. BugBot’s mean is 1.2 minutes slower and its tail is a third as long. If your team merges fast, predictable beats fast-on-average every time.

Mean latency flatters Greptile. The tail is where reviews go unread.

Re-engagement is the day-two metric nobody prices. BugBot re-reviews on 48% of multi-commit PRs and stayed engaged through a nine-commit PR. Greptile re-reviews on 36% and topped out at four. If your workflow is push, get feedback, fix, push again, that gap decides whether you have a reviewer or a one-shot scanner.

Then the finding nobody expects. Across 617 distinct (file, line) coordinates flagged by any of the four tools, 576 of them, 93.4%, were flagged by exactly one reviewer, and zero were flagged by all four.

Sit with that. The question “which tool catches more bugs” quietly assumes the tools are substitutes competing over the same finite set of defects. The overlap data says they aren’t. They’re mostly finding different things, which reframes the buying decision entirely: the honest question is whether running both is redundant, and the answer appears to be no.

Four reviewers, 617 flagged lines, almost no agreement between any two of them.

Two footnotes on the source. The post carries a 2023 publication timestamp while describing current pricing and products, so no claim in it can be dated with confidence. Treat its pricing figures as as-of-unclear and confirm with the vendors directly. That’s exactly what we did for the pricing section below.

---

How we test BugBot vs Greptile on the same 40 pull requests

This is the protocol we run each quarter and publish in full. Everything below is reproducible from the artefacts we ship.

Setup. Fork vlad-ko/pr-review-bench. Enable only Greptile and BugBot, both in default configuration, on one repository. Capture every comment verbatim to SQLite across a minimum of 40 merged PRs. Two reviewers hand-label each finding as real bug, style, or false positive, with disagreements resolved by a third.

What we publish per tool: findings per PR, false-positive rate, severity mix, time-to-first-finding at mean and P95, percentage of findings shipping an applyable fix, and percentage of PRs where the tool re-reviewed after a fix push.

The seeded subset. Alongside the organic PRs we inject 10 known bugs of deliberately distinct classes, one per PR:

1. Cross-file signature break, with a caller three modules away not updated
2. Race condition on a row that does not exist yet at write time
3. Null dereference reachable only behind a feature flag
4. Off-by-one in pagination boundaries
5. A test that asserts the library’s behaviour rather than the fix
6. Broken error path inside a catch block that swallows the original exception
7. Unbounded query added inside an existing loop
8. Timezone-naive comparison against a UTC-stored timestamp
9. Missing index causing a full scan on a table the diff doubles in size
10. Secret read into a log line at debug level

Those ten classes are chosen so that a diff-only reviewer and a repo-indexing reviewer should visibly diverge. Bug 1 requires the index. Bug 5 requires reading test intent. Bug 3 requires reasoning about a config path not present in the diff.

The scorecard readers screenshot. Ten distinct bug classes, two tools, no partial credit.

Side-by-side comment anatomy. For any seeded PR where both tools comment on the same file and line, we reproduce both comment bodies as screenshots and annotate what each one tells you that the other doesn’t: severity framing, whether the root cause or only the symptom is named, and whether an applyable fix is attached.

Same line, same bug, two very different things to read at 5pm on a Friday.

Configuration, stated plainly. Default settings. No custom rules. No contact with either vendor. Greptile’s sequence diagrams were left on for the first 20 PRs and disabled for the second 20, with the effect on perceived signal quality recorded by the labellers.

What this test cannot tell you. Forty PRs on a single language stack is not a statistically significant sample, and we don’t claim it is. It cannot measure how either tool behaves after custom-rule tuning, on a monorepo above a few million lines, or on a language neither vendor’s training data covers well. It measures out-of-the-box behaviour on one codebase, which is precisely the condition most teams evaluate under, and nothing more.

The harness, the seeded-bug repository and the labelled findings CSV are published so you can re-run it and disagree with our labels.

---

Noise, and what your team learns to ignore in a BugBot vs Greptile trial

A reviewer your engineers have learned to scroll past has an effective catch rate of zero, whatever its benchmark score says. CR-Bench documents low signal-to-noise driving developer fatigue and eventual abandonment of AI review tools in production workflows (via Augment).

BugBot averaged 0.91 comments per PR in Macroscope’s 118-bug benchmark, the lowest of any tool measured there, with all of them classified as runtime-relevant. CodeRabbit averaged 10.84 in the same test. That’s a vendor-run number, but the independent 3.5-week run measured BugBot at 2.6 findings per PR on a completely different codebase. Different number, same direction. Two sources with opposed incentives agreeing on direction is worth more than either figure alone.

Greptile came out quieter still in the independent run: 2.2 findings per PR, the lowest density of the four tools tested.

Which flatly contradicts the “Greptile is a noise firehose” framing that the alternatives listicles lead with. Surmado’s uncited 60%-nitpick claim points the same direction and rests on nothing. The only measurement anyone has published on a neutral codebase puts Greptile at the bottom of the volume table, not the top. Name that when you see it repeated.

Two architectures, converging on similar comment counts, failing differently when they’re wrong:

• BugBot suppresses at generation time. Eight passes vote; findings without consensus never post. When it’s wrong, it’s silently wrong. The bug was seen by two of eight passes and voted down.
• Greptile suppresses by scope. It mostly speaks only on correctness-class issues. When it’s wrong, it’s confidently wrong at length, because the finding cleared its bar for “this violates your own conventions.”

The measurement to run in week one, regardless of which you trial: count comments that produced a code change, divided by total comments. That fix rate is your real precision number. It costs nothing to compute and it is the only precision figure calculated on your bugs, your reviewers and your standards.

---

From finding to fix, suggestion blocks against Fix in Cursor

Greptile ships GitHub-native suggestion blocks on 32.5% of findings. Roughly one in three comments carries an “Apply suggestion” button that anyone can commit from a browser on a phone, with no tooling, no editor and no local checkout. This corrects a claim that appears across the roundups: that Greptile only describes problems and never offers fixes.

BugBot ships 0% one-click fixes inside GitHub. Its fix affordance is a “Fix In Cursor” deep link, plus Autofix agents running in isolated VMs. Cursor reports that more than 35% of Autofix changes get merged (vendor figure, via Macroscope). Read that as a ceiling under favourable conditions, not a promise.

The consequence deserves stating without hedging: for an engineer on VS Code, JetBrains, Vim or Emacs, BugBot’s headline feature is invisible. They get prose. A well-written paragraph explaining a real bug, which they then fix by hand like it’s 2023.

The fork on the right-hand branch is what most teams discover in week two.

Greptile’s deeper fix path hands off to an external agent (Anthropic’s Claude Code, OpenAI’s Codex, or Cursor) with no CI validation loop closing behind it. That’s a structural fact about handoff versus closed loop. Note that the most aggressive framing of it comes from Macroscope, which sells an integrated loop, so take the structure and leave the adjectives.

Decision rule: if fewer than about 70% of your engineers use Cursor, price BugBot as a prose-only reviewer. That is what the majority of your team will actually receive.

---

Can you gate merges on it? Check-run behaviour compared

Platform teams ask this in the first meeting and no comparison page answers it.

BugBot registers a Cursor Bugbot check run predictably on every PR, with a stable conclusion encoding. It was one of only two reviewers in the 3.5-week evaluation with dependable status-check behaviour (dev.to).

Greptile’s check run was intermittent in that same evaluation. Present on some PRs, absent on others, in the same repository, the same week, under the same configuration. The team’s workaround was to treat Greptile as advisory-only and audit its inline comments through a separate step.

Both share a trap that has nothing to do with either vendor’s quality. GitHub renders a neutral check conclusion as a grey square, which a human scanning a checks list reads as “didn’t fail.” In the evaluation this produced a near-miss merge: a PR with unaddressed findings looked clean at a glance. Configure branch protection so that neutral is treated as blocking, not passing.

Practical guidance before you write the branch protection rule: confirm the check run appears on 20 consecutive PRs. Do not gate merges on a reviewer whose check appearance you cannot reproduce. Greptile’s 38-minute P95 is a second, independent reason not to put it in the blocking path. A required check that arrives half an hour late is a required check your team will ask you to remove.

---

Real cost, where the BugBot vs Greptile pricing models stop comparing

Direct answer: The two models no longer mirror each other, they have swapped axes (verified 2026-10-19). Bugbot bills per PR review at roughly $1.00 to $1.50 with no seat component, from Cursor Premium $30 upward. Greptile bills $30 per seat plus $1 per credit over 50, per author, never pooled, with Apex depth at 10 credits. The crossover is set by PRs per developer, not by either list price.

Prices originally verified 4 August 2026, re-verified 2026-10-19. This category re-prices within months; confirm before signing.

The Bugbot side of this section is superseded. The $40/user/month seat and the 200-PR pooled cap below were removed effective each customer’s first renewal after 8 June 2026. Bugbot is now listed from the Cursor Premium tier at $30/month upward with usage billing at roughly $1.00 to $1.50 per PR review and a dash on Free and Plus. The current Cursor ladder is Free, Plus $8, Premium $30, Super $100, Ultra $200, Teams from $30 per user (verified 2026-10-19). The scenario table below is retained because the skew analysis on the Greptile side is still correct and still the most useful thing in this comparison, but read the Bugbot column as historical.

Here is the corrected shape of the same scenarios under current pricing, 10 engineers and 400 PRs a month:

Scenario (10 engineers, 400 PRs/month)	Greptile (verified 2026-10-19)	Bugbot (verified 2026-10-19)
Even distribution, 40 PRs each	$300 seats + $0 overage = $300	~$400-600 usage + Cursor seats = $700-900
Skewed, 2 authors at 150 and 8 at 12.5	$300 + $200 overage = $500	$700-900, unaffected by skew
Skewed, Greptile pre-Series A 50% off	$150 + $200 = $350	$700-900
Apex depth default on, even distribution	400 reviews x 10 credits = 4,000 credits, 500 included, $3,800 overage + $300 = $4,100	$700-900

Two readings fall out of that. Greptile is cheaper than Bugbot in every row except the Apex one at this PR-to-developer ratio, which inverts the original table and happened purely because Bugbot moved from seats to usage. And turning Apex depth on as a default is a 13x cost multiplier at this volume, which is by far the largest single cost lever either product exposes. Reserve Apex for changes you would otherwise send to a human design review.

Below is the original 4 August 2026 analysis, retained for the skew argument.

Greptile: $30/seat/month, 50 reviews included per seat, $1 per additional review, and it is billed per author, not pooled (Macroscope).

Work the example, because the pooling word is doing all the work. One engineer pushes 80 PRs in a month. A teammate pushes 20. Team-wide you’ve bought 100 reviews and used 100. Your invoice still carries 30 overages at $1 each, because the heavy author blew through their personal allocation while the light author’s sat unused. Skew is not free under this model. It’s billed.

Greptile Chat is a separate add-on at roughly $20/seat/month. A 10-person team buying review plus codebase Q&A is at about $500/month before a single overage. If you already run Claude Code or Cursor, you probably don’t need Chat at all. Worth saying, because the roundups quoting $500 quietly assume you buy it.

BugBot, as priced on 4 August 2026 and now superseded: $40/user/month monthly, roughly $32 on annual, with a 200 PR/user/month cap on Pro that pools across the team, plus a Cursor IDE subscription if you were not already buying those seats. All of that was removed effective each customer’s first renewal after 8 June 2026 (verified 2026-10-19).

The two models are mirror images. Greptile’s per-author allocation punishes uneven PR distribution; BugBot’s pooled cap absorbs it.

Scenario (10 engineers, 400 PRs/month)	Greptile	BugBot
Even distribution (40 PRs each)	$300 + 0 overage = $300	$400, well under 2,000 pooled cap = $400
Skewed (2 authors at 150, 8 at 12.5)	$300 + 200 overage = $500	$400
Skewed + startup discount	$150 + 200 = $350	$400
Skewed + Chat add-on, no discount	$500 + 200 = $700	$400

The skew input is the whole point. No competitor models it, and it’s exactly where the two pricing models diverge.

The discount nobody advertises. Greptile offers 50% off for pre-Series A startups under $2M revenue, effectively ~$15/seat, and free reviews for OSS repositories under MIT, Apache or GPL licences. Both live in a “Special Programs” footer (dev.to). At $15/seat, Greptile is cheaper than BugBot in nearly every configuration we modelled, which inverts every pricing comparison currently ranking for this query.

Confirm the BugBot seat-coupling question in writing on the order form before you sign. The list price is meaningless if half your engineers also need a Cursor licence to get value from it.

---

Hard filters that end the BugBot vs Greptile comparison early

Platform. BugBot is GitHub-only. On GitLab, Bitbucket or Azure DevOps the comparison is already over. Greptile covers GitHub, GitHub Enterprise and GitLab. For Bitbucket or Azure DevOps you’re looking at CodeRabbit or Qodo (Surmado).

Self-hosting and air-gapped environments. Greptile Enterprise supports self-hosted deployment. BugBot is cloud-only. In a regulated environment that’s a one-line disqualification, not a trade-off.

Data handling. Neither vendor publishes the answers, and no page ranking for this query publishes them either. Send these five questions in writing:

1. What is the retention window for diffs and indexed source, and is it configurable?
2. Is customer code used for model training or evaluation, under any conditions including opt-out defaults?
3. Which subprocessors and model providers see the code, named individually?
4. Is a current SOC 2 Type II report available under NDA, and what is the observation period?
5. On indexing: where does the index live, and is it deleted on cancellation?

Language coverage. Both are LLM-based and language-agnostic in principle, so “does it support Rust” is the wrong question. Ask instead about indexing limits on very large monorepos and re-index latency after a large merge, since that’s where full-repo indexing actually strains.

Four questions eliminate one tool for most teams before any benchmark matters.

---

Is Greptile open source? Is BugBot? No, and no

Neither product in the BugBot vs Greptile pair ships an open-source review engine. Both are hosted SaaS installed as a GitHub App.

Greptile does publish some MIT-licensed tooling. greptileai/greptile-vscode is MIT, 96 stars, 11 open issues, and was last pushed on 15 September 2024, roughly two years stale. A public repository that hasn’t moved in two years tells you where a company’s attention went. It is not evidence of an open-source product.

Two of those open issues are basic install-time breakage nobody has closed: keybindings not auto-configured on install and repository entry fields not rendering at all. Report them as what they are. An unmaintained side repo, not a verdict on the PR reviewer, which is a separate closed-source product with a real team on it.

The namesake trap. Searching GitHub for “bugbot” surfaces unrelated projects, most prominently Kingdragony/Tiger-Bugbot-Radiation with 94 stars, 9 open issues, no licence, last pushed 8 April 2025. It has nothing whatsoever to do with Cursor’s BugBot. Several AI answer engines conflate the two and will confidently tell you BugBot is open source on the strength of it.

If open source is a hard requirement, the real option is Qodo Merge / PR-Agent: self-hostable, runs on your own LLM keys, roughly 8,500 GitHub stars (Surmado).

---

Where each one breaks

Every BugBot vs Greptile failure mode below links to a primary source. None comes from a vendor’s marketing page.

Greptile’s intermittent check run. Appeared on some PRs and not others within the same repo, same week, same config, making it unusable as a required merge gate without a workaround (dev.to).

Greptile’s sequence diagrams, on by default. Described by the evaluating team as uniformly unhelpful and occasionally wrong about call ordering. Signal quality reportedly improved the moment they were disabled in repo settings. Same source.

Greptile’s latency tail. Mean 4.9 minutes, P95 38 minutes. A non-trivial slice of reviews land long after the developer has context-switched away. Same source.

Greptile’s per-author, non-pooled overage billing. The most-cited migration driver across the alternatives roundups (Macroscope). Treat the driver as real and the destination recommendation as marketing.

BugBot’s fix affordance is Cursor-only. 0% one-click fixes in GitHub. Non-Cursor engineers get prose. Same dev.to source.

BugBot’s historical IDE-seat coupling and billing opacity. Invoice line items that didn’t map cleanly to dashboard activity, requiring repeated support tickets. That combination, not review quality, is why one evaluating team cut a tool they rated in the top half on quality. Same source.

BugBot is GitHub-only and cloud-only. No GitLab. No self-hosting. Nothing to negotiate.

A caveat that cuts both ways, in the interest of honesty. Sustained bugs in commercial AI reviewers get reported through private vendor support channels, not public trackers. The absence of public issues for either product is not evidence of reliability, and you should not read it as such. Where you can read failure modes directly is in the open-source-adjacent corner of the category: a community repo for CodeRabbit carries an open report of the bot stuck in an infinite retry loop, generating unit tests on a closed PR and ignoring stop commands (awesome-coderabbit issue #19). That’s a community repository, not the product’s tracker. It’s included to show the class of thing that happens and never surfaces publicly for closed vendors.

---

Roadmap risk, what changes the BugBot vs Greptile answer in 12 months

Cursor acquired Graphite in late 2025 (reported December 2025). Graphite Diamond and BugBot are expected to converge, which means BugBot’s feature surface and packaging are in motion, not settled (Macroscope).

The unbundling question stays unresolved on the public pricing page. A $40/user tier exists. Whether developers without a Cursor IDE seat can be enrolled standalone cannot be determined from that page. Put it in the order form.

At the category level, one artefact captures the state of the discourse better than any analysis: in a Hacker News thread titled “There is an AI code review bubble”, a Greptile representative directs readers to greptile.com/benchmarks and greptile.com/greptile-vs-bugbot. The head-to-head content in this space is overwhelmingly vendor-authored, including several pages ranking for this exact query.

Contract advice: avoid annual lock-in in a category where a top-five vendor was acquired inside twelve months. Prefer monthly, or a six-month term with a platform-support clause that lets you exit if promised platform coverage slips.

---

Run the BugBot vs Greptile bake-off yourself in two weeks

Pick 15 PRs. At least 3 that cross service boundaries or change shared libraries. At least 3 single-file isolated changes. At least 3 historical PRs where a bug actually reached production. Those are your ground truth, and they’re the only PRs in the set where you know the right answer.

Run both simultaneously, same repo, default config. Do not tune one and not the other. Record the config.

Measure four things. Fix rate: comments that produced a code change divided by total comments. Miss rate on your known-bug PRs. Time-to-first-finding at P95, not mean. Number of comments your engineers replied to unprompted, which is the closest proxy for trust you can measure in two weeks.

Check the check run. Confirm the status check appears on all 15 PRs and encodes findings in a form your branch protection rule can read. Every evaluation guide in this category skips this and every platform team gets burned by it.

Run one deliberate fix-push cycle per PR. Push a fix, then record whether the tool re-reviews or goes silent. The gap between 48% and 36% re-engagement is the gap between a reviewer and a one-shot scanner, and you’ll only see it if you test for it.

Budget the trial at zero. Both vendors offer trial or free-tier access, and if your repo is MIT, Apache or GPL licensed, Greptile reviews it free indefinitely under its OSS programme. That’s a no-cost way to see real output on real code before a procurement conversation starts.

---

If neither fits, the honest alternatives

Direct answer: If Bugbot’s GitHub-only limit or Greptile’s missing Azure DevOps disqualifies both, the verified alternatives are CodeRabbit for the widest platform coverage, PR-Agent for genuine self-hosting under MIT since 23 April 2026, Kodus under AGPLv3 free to self-host at any size, and Gitar for Azure DevOps Services and Server - though Gitar does not support GitHub Enterprise Server (verified 2026-10-19).

Constraint	Choose	Why
GitLab, Bitbucket or Azure DevOps	CodeRabbit or Gitar	CodeRabbit has the broadest coverage; Gitar covers Azure DevOps Services and Server but not GHES (verified 2026-10-19)
Self-hosted / data residency	PR-Agent or Kodus	PR-Agent is MIT since 23 April 2026 under independent community governance; Kodus is AGPLv3, free to self-host at any team size
Perforce or Gitea	Greptile	Only product in our 51-tool matrix documenting Perforce with P4 Code Review
Volume and applyable diffs over selectivity	CodeRabbit	68.3% of findings ship a unified diff, highest applyability in the independent run, at the highest comment volume
Production-risk framing and severity calibration	Sentry Seer	Only reviewer in that dataset using a “critical” label; 6/6 on it, 15% FP at “high”
Python-heavy, budget-constrained, want pre-PR feedback	Sourcery	~$10/seat with IDE-time review
Open source hard requirement	Qodo Merge / PR-Agent	~8,500 stars, self-hostable

Adjacent products come up in every procurement thread and none of them are in the tables above, because we have not run them on this harness: GitHub Copilot code review, Semgrep, SonarQube, Snyk Code, Codacy and Ellipsis. The first is bundled with a licence many teams already hold; the rest are static analysis or security scanning rather than LLM PR review. Different job, different failure modes, worth pricing separately.

Three of the pages currently ranking for “bugbot vs greptile” are selling a product inside the comparison: Macroscope, Augment Cosmos and Surmado. Their products may well be good. Evaluate them. Just don’t evaluate them on the numbers published in their own comparison posts, where they refereed their own match.

---

The BugBot vs Greptile verdict, by team profile

Cursor shop, GitHub, 5 to 30 engineers, noise is the complaint → BugBot. The Fix-in-Cursor loop and the predictable check run justify the premium, but only because the editor is already a line item.

Mixed-editor team on GitHub → Greptile. BugBot’s headline feature evaporates for the JetBrains and VS Code half of your team, and you’d be paying $40/user for prose.

GitLab, or self-hosting required → Greptile. No contest. BugBot isn’t in the running.

Pre-Series A startup or OSS maintainer → Greptile at ~$15/seat, or free for MIT/Apache/GPL repos. This makes it the cheapest serious option in the category and almost nobody knows the programme exists.

Uneven PR distribution, a few very heavy committers → BugBot, and the reason is now stronger. Greptile’s per-author credits do not pool, so a team where two engineers open most of the PRs pays overage on exactly those two seats. Bugbot has no seat component at all since 8 June 2026 - it bills on PR volume regardless of who opened them (verified 2026-10-19), so skew is structurally free. If your distribution is lopsided, this is the single cleanest argument in the comparison. The other structural answer to skew is Qodo, whose credits do pool across the team at $0.012 each.

You need a required merge gate → BugBot today. Or Greptile advisory-only with a separate audit step, until its check-run consistency is something you’ve verified yourself on 20 PRs.

And the uncomfortable recommendation the overlap data supports: 93.4% of flagged coordinates in the independent run were caught by exactly one reviewer. These two tools mostly find different bugs. For a high-stakes repository, the correct answer may be to run both for a quarter and cut the one your engineers reply to less.

---

Frequently Asked Questions

What is the alternative to BugBot?

BugBot is GitHub-only and cloud-only, so platform decides your answer. On GitLab, choose Greptile ($30/seat) or CodeRabbit. On Bitbucket or Azure DevOps, CodeRabbit or Qodo Merge. If you’re leaving over Cursor seat coupling rather than platform, Greptile is the closest like-for-like on selectivity.

Is Greptile worth it?

Worth it if you’re on GitLab, need self-hosting, qualify for the ~$15/seat pre-Series A rate or free OSS reviews, or your recurring bugs are cross-file architectural ones. Not worth it if you need a required merge gate, or if a few heavy authors dominate your PRs, where non-pooled $1 overages bite hardest. Its 82% catch rate is Greptile’s own benchmark.

What is Greptile?

Greptile is an AI code reviewer from YC W24 that indexes your entire repository into a dependency graph and reviews pull requests with codebase-wide context instead of just the diff, on GitHub, GitHub Enterprise and GitLab. It began as codebase Q&A, which is why Greptile Chat remains a separate ~$20/seat add-on rather than a bundled feature.

Is Greptile open source?

No. The review engine is closed-source hosted SaaS, installed as a GitHub App. Greptile publishes MIT-licensed side tooling such as greptileai/greptile-vscode (96 stars, 11 open issues), but its last commit was September 2024. For a genuinely open-source reviewer, use Qodo Merge / PR-Agent, self-hostable with your own LLM keys.

Is Cursor BugBot open source?

No. BugBot is a hosted GitHub App from Cursor with no public source repository. Be careful with GitHub searches: unrelated namesake projects such as Tiger-Bugbot-Radiation (94 stars, no licence, last pushed April 2025) have nothing to do with Cursor, and AI answer engines sometimes present them as Cursor’s product.

Which catches more bugs, BugBot or Greptile?

No neutral BugBot vs Greptile benchmark answers this. Greptile’s own study puts it at 82% versus BugBot’s 58%. Macroscope’s study puts BugBot at 42% versus Greptile’s 24% on an incomplete 72-of-118 denominator. Both parties sell against the loser. The independent run found comparable density, 2.2 versus 2.6 findings per PR, with 93.4% of flagged coordinates caught by exactly one reviewer.

How much does BugBot cost compared to Greptile?

BugBot is $40/user/month, roughly $32 annual, with a 200 PR/user/month Pro cap pooled across the team, plus a Cursor IDE seat if you don’t already buy one. Greptile is $30/seat/month, 50 reviews included per seat, $1 per extra review billed per author and not pooled. Chat is ~$20/seat extra. Verified 4 August 2026.

Can I use BugBot without Cursor?

A standalone BugBot tier is listed, but the fix affordance only functions inside the Cursor editor, so engineers on VS Code, JetBrains or Vim receive prose-only findings. Confirm seat coupling in writing on the order form before signing. IDE coupling was the deciding reason one evaluating team cut a tool it rated top-half on quality.

Greptile vs CodeRabbit: how does that change the answer?

CodeRabbit is the volume-and-applyability choice: 68.3% of findings ship a unified diff in the independent run, the highest applyability measured, plus coverage of GitHub, GitLab, Bitbucket and Azure DevOps. It’s also the only one of the three ranked #1 on a benchmark it didn’t run itself (Martian, March 2026). The trade-off is comment volume.

Greptile vs Graphite: is Diamond still a real option?

Cursor acquired Graphite in late 2025 and Diamond is expected to converge with BugBot, making it a roadmap risk rather than an independent choice. In Macroscope’s 118-bug benchmark it produced very few false positives and very few catches, which positions it as a second-opinion reviewer rather than a Greptile replacement.

What do people on Reddit and Hacker News actually say?

Most head-to-head content in this category is vendor-authored, including a Greptile representative pointing readers to greptile.com/greptile-vs-bugbot inside an HN thread titled “There is an AI code review bubble”. Recurring practitioner themes: noise fatigue, comment volume on large diffs, and tools being ignored permanently once trust breaks.

Can I run BugBot and Greptile at the same time?

Yes, and for evaluation it’s the approach we recommend. Both install as GitHub Apps and run independently of your CI, so neither can break your pipeline. The 93.4% single-reviewer overlap figure is why a parallel run is informative rather than redundant. Set a two-week window and a kill criterion: whichever tool’s comments engineers reply to less.

---

How we verified this

What we checked, and where. The original head-to-head was run on 40 pull requests and the pricing was verified on 4 August 2026. Every price, platform and compliance fact was then re-checked against the vendors’ own pages on 2026-10-19: the removal of Cursor Bugbot’s standalone $40 seat effective each customer’s first renewal after 8 June 2026; the current Cursor ladder of Free, Plus $8, Premium $30, Super $100, Ultra $200 and Teams from $30; the roughly $1.00 to $1.50 per-review usage figure from Cursor’s help documentation; the .cursor/BUGBOT.md path and the .cursor/config/bugbot.yaml keys; Cursor’s ISO/IEC 42001:2023 certification and its Enterprise HIPAA BAA; the Cursor acquisition of Graphite on 19 December 2025; Greptile’s three tiers with Starter free for 1 active developer; Greptile Pro at $30 per seat with 50 credits, $1 per extra credit, per author and not pooled; Apex depth at 10 credits per review; and Greptile’s platform list including Bitbucket Data Center, Gitea and Perforce with P4 Code Review, with Azure DevOps absent.

What we corrected on this page. Nine facts. The Bugbot $40 standalone seat and its 200-PR pooled cap, both gone. Greptile’s platform list, which understated coverage by three platforms. The claim that Greptile has no free tier. The unit of Greptile’s allowance, which is credits rather than reviews, with Apex at 10 each. The undated Greptile Series A, which was $25M led by Benchmark in September 2025 and is misdated to 2026 in several places. The BUGBOT.md config path. The absence of any compliance row, where Cursor has two real certifications Greptile does not. The site name in the disclosure, which read as another publication. And the “Pick Bugbot for pooled skew absorption” argument, which is now stronger rather than weaker and for a different reason.

What we could NOT verify. No neutral benchmark scores both tools. The four benchmarks in the provenance table above were each run by a party selling against the loser, and the spread for Greptile alone, 24 percent to 82 percent, is wider than any measured gap between the two tools. We could not re-verify Greptile Chat at roughly $20 per seat per month at source on 2026-10-19, so treat that figure as carried from the August test. We could not verify any Greptile annual-contract discount - none is published. We could not verify Greptile’s data retention terms or a SOC 2 report; both must be requested. Neither vendor publishes a support SLA, net payment terms or a purchase-order process, which is market-wide: zero vendors in our set of 51 publish any of the three. We also could not re-run the 40-PR harness on 2026-10-19, so every quality and noise figure on this page is from the 4 August 2026 run and should be read with that date attached.

The claim this page refuses to make. No party without a commercial stake has published a false-positive rate, precision figure or noise measurement for any shipping commercial AI code reviewer. That holds for both tools here. The genuinely non-commercial benchmarks - SWE-PRBench and CR-Bench - measure bare models in fixed harnesses, not products you can buy, which is exactly why they do not settle this comparison. The neutral Martian Code Review Bench does not score Greptile at all and has had four separate vendors each declare themselves number one on it. Our own measurement design is pre-registered at the AI code review noise index methodology before any results exist, specifically so it cannot be tuned to a conclusion.

Conflicts we are disclosing. Gitar appears twice on this page and Gitar is a paid sponsor of aicodereview.cc - its unsupported-GHES status and its lack of any published third-party benchmark are stated anyway. Macroscope, Augment and Surmado all rank for this query while selling a product inside their own comparison, and Harness acquired Augment’s Cosmos, Auggie CLI and Code Context Engine on 8 October 2026. We name the funder of every number. Method at standards.

Corrections log. This page carries a visible correction log and is re-tested each quarter. Last bake-off: 4 August 2026. Last fact re-verification: 2026-10-19. If a price, a repo metric or a benchmark figure here has moved, send the primary source and we will date-stamp the correction.

Further Reading

• AI Pull Request Review on Bitbucket: 8 Tools Tested
• CodeRabbit vs Cursor Bugbot: 2026 Cost & Bug Data
• CodeRabbit vs Greptile
• Greptile vs Claude Code
• Greptile pricing
• Cursor pricing
• AI code review benchmarks compared
• AI code review tools with low false positives