Custom review agents per repository

Spin up named reviewers with focused instructions — a Security agent that watches auth boundaries, a Style agent that flags repo-specific conventions, anything you want. Each agent reviews PRs alongside the default reviewer, posts comments under its own label, and tracks fixes independently across follow-up pushes. Manage agents from your repository's Agents tab.

Remove agents you no longer need

Agents you've outgrown can now be permanently removed from your repository's Agents tab. Existing comments on past PRs stay where they are — only future reviews are affected. You can re-create an agent with the same name later if you change your mind.

Faster, cleaner repository learnings

Lessons the bot picks up from your feedback now live alongside your reviews — quicker to retrieve during review and with fewer noisy duplicates. The reviewer's understanding of your team's conventions stays sharp as your feedback history grows.

Faster reviews on follow-up pushes

When you push new commits to an open PR, the reviewer now focuses on what changed since the last review instead of re-reading the entire PR. Faster turnaround, fewer redundant comments, and less waiting on every push. The first review on a PR still covers the whole thing — and you can always comment @revvu-ai review to force a fresh full-PR pass.

Reviews finish faster

Each part of a review now completes in under 90 seconds, down from a worst case of several minutes. Large pull requests no longer time out, and the overall review on a medium PR drops from 4–8 minutes to 1.5–3 minutes.

Multi-page docs at /docs

Eleven deep-dive pages now live at /docs/getting-started, /docs/how-it-works, /docs/mentions, /docs/inline-comments, /docs/dashboard, /docs/configuration, /docs/triggers, /docs/fix-detection, /docs/learnings, /docs/security, and /docs/faq. The /docs hub groups them by audience — journey-style guides for first-time installers and daily users, reference pages for repo admins and buyers — and the configuration page documents every per-repo setting in one place.

Pushing or closing a PR cancels the in-flight review

Previously, a fix-up push or a PR close could leave the previous review still running in the background — producing duplicate inline comments on stale SHAs and wasting tokens on work nobody wanted. A new commit now cleanly supersedes the previous review, and closing a PR stops the review immediately.

Conversational @mentions

Mention Revvu on any PR comment — ask a question about the diff, teach a rule that should shape future reviews, or ask for a fresh pass. Revvu replies in the thread.

Second-pass verification catches findings the reviewer almost dropped

After the main review finishes, a quick audit pass looks for issues the reviewer reasoned about but didn't actually flag — the classic 'probably intentional' suppression that hides real post-refactor bugs. Anything the audit escalates merges into your review like any other finding, so you see it on the PR instead of buried in a reasoning trace. Disable it in repo Settings if you want to skip the extra pass.

Tunable asymmetry threshold in repo settings

The repo Settings tab has a new Minimum confidence — asymmetry findings knob, separate from the global confidence threshold. Tune it up to suppress speculative asymmetries, or down to surface more. Asymmetry also appears as a toggleable category in the findings allowlist.

Post-refactor sibling bugs caught more reliably

Reviews now recognize asymmetry findings — when a refactor changes one place but leaves a sibling call site doing it the old way — as their own category, with a dedicated lower confidence threshold. Previously these were lumped in with regular bugs and dropped whenever the reviewer wasn't fully certain. The new default surfaces them at confidence 5+ (vs. 7+ for other categories), so suspected sibling divergence actually reaches you.

Reviews cancel automatically when you push again

Pushing a new commit while a review is still running now cancels the old one and starts a fresh review on the latest code. No more duplicate comments on a stale commit.

Closing or merging a PR stops the review

If you close or merge a pull request mid-review, the review halts immediately — no stray comments land on a closed PR.

Cleaner, more consistent inline review comments

Review comments now always read as a clear explanation of the issue plus an agent-ready prompt you can hand to Claude Code, Cursor, or any AI assistant. The inline 'Commit suggestion' block has been dropped — it was fragile on multi-line fixes and couldn't attach to issues outside the diff. Every comment now applies the same way, and the dashboard renders them consistently.

Support tickets saved to your account

Open a support ticket from the dashboard and it sticks around across sessions and devices. Reply to the thread later to add context, resolve a ticket when it's handled, or reopen it if something flares up again — everything's stored to your account instead of just your current browser.

Faster reviews on large PRs

Related files in the same pull request are now reviewed together and in parallel. Wall-clock time on multi-file changes drops noticeably, and the reviewer can catch bugs that span files — like a rename that only landed in some call sites, or an interface change with a stale caller. Small PRs still review the same way.

Safer one-click fixes on review comments

When a review comment points at code outside the pull request's diff, the reviewer no longer attaches a 'Commit suggestion' button to it. Previously that button could land a fix at the wrong line and break the file; now the comment explains the fix in prose instead, so a quick click-to-apply never produces a broken commit.

Reviews post reliably on every pull request

Intermittent routing hiccups could cause a review to fail mid-run, so some pull requests opened or pushed would end up with no comments at all while others reviewed normally. Reviews now pin themselves to backends that fully support the reviewer's request shape, so every pull request gets the comments it's supposed to.

Live review status on the dashboard

A new "Active reviews" panel on the dashboard shows pull requests currently being reviewed, with the current phase ("Analyzing files", "Posting comments", etc.) and a live elapsed timer. The panel refreshes every few seconds while a review is running, so you can watch progress end-to-end instead of waiting for the final comments to appear on GitHub.

Per-repo page shows active reviews for that repo

Opening a repository's detail page now surfaces any in-flight review for that repo at the top, with the same live status indicator. Useful when you want to watch a specific repo's review without scanning the full dashboard.

Live review progress on GitHub

The Revvu Review check on your pull request now updates in place while the review runs — showing what the bot is working on (gathering context, reviewing each file by name, posting comments) instead of the generic "This check has started…" placeholder. You always know whether the review is actually moving.

Resolved comments are recognized on large deletions

If you addressed a review comment by deleting the surrounding code entirely, the next review would sometimes still report the issue as open. The bot now reliably recognizes these fixes and marks the thread resolved with the usual acknowledgement reply.

Large PRs no longer time out mid-review

Pull requests with lots of changed files previously could fail partway through review when the total processing time overran our platform's per-request limit. Each file is now reviewed in its own processing slot, so the review always finishes — and if one file hits a transient error, only that file is retried instead of the entire run restarting from scratch.

About, Careers, and Docs pages

The footer's About, Careers, and Docs links now open real pages — each laid out in the same style as the rest of the marketing site. Docs gives you a quickstart, guides, and a jumping-off point to settings and support. Careers explains how the team works and what we're looking for. About lays out the principles that shape every review.

Sharper link previews when Revvu gets shared

Every link to Revvu now renders with a proper Open Graph preview on X, LinkedIn, Slack, Discord, and iMessage — the Revvu mark, the tagline, and a one-line description in a dark-mode card that matches the product.

Remove a single learning from the dashboard

Each learning on the Learnings tab now has a remove button. If a learning was captured from off-base feedback, you can drop it in two clicks — the AI stops applying it to future reviews immediately.

Clear all learnings for a repository

A Clear all button at the top of the Learnings tab wipes every learning for the repo at once, with a confirmation. Useful if you want a fresh start after a major refactor or a noisy feedback period.

Per-file reviews now arrive with a PR-level briefing

Before scanning each file, the reviewer now generates a short briefing of the PR's intent, cross-cutting patterns, and risk areas — and every per-file review starts with that briefing as orienting context. The reviewer no longer rediscovers the PR's overall shape from each file's diff in isolation, which means fewer back-and-forth tool calls and more consistent findings across files. You can disable the briefing per repo if you want to skip the +1 call on small PRs.

Each file review is capped at 4 investigation rounds

The reviewer used to budget up to 10 rounds of file lookups per file, even when most of those rounds returned diminishing-value information. The cap is now 4 — enough to verify a finding against its surrounding context without burning tokens on redundant exploration. You can override per-repo if you want deeper investigation on a specific codebase.

Team memories are now matched per file, not per PR

Instead of fetching memories that match the PR title and using the same set across every file, the reviewer now searches the team memory store per file (using the filename and diff hunk). Each file gets memories targeted to what's actually changing in it — fewer false matches, more relevant context.

The reviewer no longer re-fetches files it already has

Each per-file review now starts with an explicit list of which files are already in context. Combined with cost framing in the system prompt, this stops the model from spending rounds re-reading the same files. Most reviews finish noticeably faster.

Support tab in the dashboard sidebar

A dedicated Support page lives under Account in the sidebar. Open a ticket with a category (bug, billing, feature, other), priority, related repository, and description — and track open, waiting, and resolved tickets side-by-side without leaving the dashboard.

Inline ticket threads with reply, resolve, and reopen

Each ticket expands into its own message thread with quick actions — reply to keep the conversation going, mark it resolved when you're done, or reopen it if something comes back.

Filter and search your tickets

Status filters (All / Open / Waiting / Resolved) and an inline search for subject, ticket id, or repo so finding the ticket you're looking for stays fast as the list grows.

Reviews skip low-value files automatically

Lockfiles, markdown, env files, package.json, and pure-deletion changes no longer enter the LLM review path — these have no shape for AI scans to find real bugs (typecheck, tests, and CI catch them more reliably). Big PRs with lots of mechanical edits finish noticeably faster, and your token bill drops accordingly. You can switch this off per repo in settings if you want every file inspected.

Every file in a PR gets reviewed

On larger PRs some files could quietly get skipped when upstream limits kicked in. Reviews now work through each file in sequence so coverage is complete, even if the overall review takes a bit longer on big PRs.

Reviews keep their focus on every file in large PRs

Big PRs used to get uneven attention — issues near the top landed fine, later files got skim treatment. Each changed file now gets its own dedicated review pass with just the code that matters to it, so findings are consistent across the whole PR.

Cmd+K palette gets scope chips and prefix shortcuts

The palette now organizes results into All, Actions, Reviews, Repos, and Settings scopes — with live counts and a one-key prefix (>, #, @, /) to jump between them without lifting your hands from the keyboard.

Richer result rows with inline context

Each row now shows an icon, a bolded match highlight on your query, a secondary metadata line, and a trailing status pill or shortcut hint — so you can pick the right item without reading the whole list.

Visible keyboard affordances

A persistent footer bar reveals navigate / open / scope / close shortcuts, and an empty-state surfaces suggested actions and recent reviews so the palette is useful the moment it opens.

Confidence threshold setting now honored end-to-end

Lowering the confidence threshold in repo settings used to have no effect — reviews kept coming back with zero comments because the reviewer was silently holding itself to the default bar. The setting is now plumbed all the way through, so dialing it down actually surfaces more findings and dialing it up surfaces fewer.

Account settings gets Notifications and API sections

Manage which events email you (weekly digest, critical issue alerts, new learnings applied) and preview the API token and webhook surfaces coming soon.

Refreshed dashboard across every page

Overview, Repos, Repo detail, Review detail, Feedback, and Settings have all been redrawn to share a consistent visual language. Eyebrows, typography, and spacing now pull your eye to what matters first on each screen.

Metrics read as one instrument panel

KPI cards across Overview and Review detail are now stitched into a single rounded card with hairline dividers. Values, deltas, and subtitles share one grid, making it easier to compare numbers at a glance.

Attention-worthy moments stand out

Needs-attention alerts, failed reviews, and removed repositories are now rendered as tinted callouts with an accent bar and inline actions — easier to spot, harder to miss.

A tidier sidebar

Navigation is now grouped into Workspace and Account, with a live count next to Repos so you always see how many you’ve connected.

Dial in what lands on the PR

Choose which categories of findings to surface (security, performance, style, testing, docs, etc.), set a severity floor to hide nitpicks, cap how many comments appear per file or per PR, and raise or lower the confidence threshold. Noisy reviews and quiet reviews are now both a couple of clicks away.

Control when reviews fire

Pick exactly which PR events trigger a review — opened, synchronized, reopened, or ready-for-review. Skip draft PRs or bot-authored PRs (Dependabot, Renovate) entirely. Restrict reviews to specific target branches, set a max diff size so giant PRs don't balloon costs, and toggle the @mention command or check re-run trigger independently.

Shape the review workflow integration

Turn off the “Nice work!” reply on fixed comments, hide the “Why this matters” section under each finding, stop updating the PR description block, or opt out of posting a GitHub Check Run — useful when your team has its own status-reporting conventions.

Tune the learning loop

Decide whether the bot consults team memory during reviews, how many learnings it injects, how strict the relevance threshold is, and which feedback classes (learnings, corrections, disagreements, questions, acknowledgements) get stored. Silent learning, aggressive learning, or none — up to you.

Advanced performance knobs

Adjust the agentic tool-rounds cap, dependency-import depth, review timeout, and whether the enrichment and project-rules steps run at all. Useful for very large repos (more depth) or low-latency gating (less depth).

Reviews actively consult your team's past feedback

Before flagging anything that might be a team convention or a previously-rejected suggestion, Revvu now looks it up in your repository's memory mid-review. Fewer comments re-raising concerns your team has already settled, and more comments that respect the way your team actually works.

You can see which team learnings shaped each review

When a past learning influences a comment, Revvu quotes it directly under the finding with 'Based on team memory'. Learnings that shape the overall review stance are aggregated in a 'Team learnings applied' section at the bottom of the PR summary — so you can tell when past feedback is paying off, instead of wondering whether Revvu remembers anything at all.

Team conventions now outrank default style preferences

Memory is the highest-priority context in every review. A learning that says 'the team intentionally does X' is treated as binding policy — Revvu won't second-guess it except for genuine bugs, security issues, data-loss risks, or API contract violations.

A PR summary in seconds, not minutes

The moment you open a PR, Revvu posts a short summary at the top — what the PR does, the key changes, any risks, and a quick recommendation — so you can skim before the full review lands. The deeper review replaces the summary in-place when it finishes.

Feedback is a conversation

Reply to a bot comment and Revvu replies back — acknowledging when it was wrong, answering questions, and remembering genuine teaching moments for future reviews without polluting memory with every back-and-forth.

Reviews grounded in real code and live docs

Revvu can now read any file in your repo and (when Context7 is configured) look up third-party library documentation mid-review. Fewer confident-but-wrong comments about code or APIs it never actually saw.

More reliable tracking across pushes

When you push new commits, Revvu is less likely to claim an issue is fixed when it wasn't, or re-post a near-duplicate of an existing comment. Open comments on files you didn't touch stay open instead of being auto-resolved.

Richer comments that explain why

Every review comment now includes a collapsible 'Why this matters' section that explains the real-world impact of the finding, so you can make the call faster.

A tighter PR summary

The summary at the top of the PR description is now a short 'what this PR does' sentence plus a bullet list of key changes — no speculative risks, no 'safe to merge' recommendations from a 10-second scan, no timestamp noise. Reviewers can skim what changed and make the merge call themselves.

No more duplicate 'Nice work!' replies on multi-push PRs

Once Revvu has marked an issue as fixed, later pushes won't re-post another acknowledgement on the same thread. The 'issues fixed' count in the review summary now reflects what was newly resolved this round instead of growing each push.

Apply-suggestion won't break your code

When Revvu proposes a multi-line fix inside a nested expression, clicking 'Apply suggestion' no longer leaves a stray closing bracket behind. Risky suggestions that would produce invalid code are caught before they're posted — the comment still shows the finding, just without the broken auto-fix.

Reviews can read any file in the repo

When a diff references a function or type defined elsewhere, Revvu now pulls in that file to check the actual signature before flagging anything. Fewer confident-but-wrong comments about code it never saw.

Library behavior is verified, not guessed

Revvu can look up documentation for third-party libraries mid-review instead of relying on what it remembers from training. Comments about deprecated APIs or version-specific behavior are grounded in current docs.

More accurate, sometimes slower

Verifying facts takes a few extra seconds on PRs that exercise it. The trade is worth it: fewer hallucinated bugs, more trust in each comment.

Smarter handling of repeat pushes

Reviews now reason about your previous comments separately from finding new issues. You'll see fewer near-duplicate comments and no more false 'fixed' acknowledgements on lines that weren't touched in a push.

Better duplicate detection across rewrites

Revvu now recognizes when a new finding is really the same underlying issue as a prior comment — even if line numbers drifted or the wording changed — and skips posting the duplicate.

Fixed comments stay open when a file isn't in the push

If a push only updates some files, open comments on other files stay open instead of being incorrectly marked as resolved.

Revvu replies to your feedback

Reply to a review comment and Revvu writes a short response back on the thread. It keeps the conversation grounded in the original finding, the file, and the severity — no more replies vanishing into the void.

Smarter about what's worth remembering

Only genuine teaching moments become persistent learnings. Disagreements get a short explanation and stay open; acknowledgments get a thank-you; questions get an answer — and none of those pollute future reviews.

Revvu owns it when it was wrong

If you correct a false positive, Revvu acknowledges the mistake and remembers not to flag that pattern again. No more arguing with the same comment on every PR.

Never drops your feedback

If the AI classifier is ever unavailable, feedback falls back to the original heuristic so nothing slips through the cracks.

Reviews check your changes against your existing tests

When a source file has a nearby test file, Revvu now reads the test alongside the change — so it can flag when an edit breaks the behavior the test was written to protect.

Deeper dependency awareness

Reviews now follow imports two levels deep instead of one, giving the AI visibility into the types and utilities your changed code indirectly relies on. This catches more subtle contract violations.

Catches issues tied to pre-existing imports

Previously the reviewer only analyzed imports added in the PR. It now considers every import in the files you changed — so bugs rooted in long-standing dependencies are no longer invisible.

Every review comment tells you why it matters

Inline comments now include a collapsible 'Why this matters' section that explains the real-world impact of each finding, so you can make the right call faster.

Clearer review summaries

The top of every review now shows a structured summary with what the PR does, a findings breakdown table (bugs found, issues fixed, still open), and an overall recommendation.

Friendlier tone when issues are resolved

When you fix a flagged issue, Revvu now replies with a warmer acknowledgement instead of a terse confirmation — small change, more human feel.

Invite to teach Revvu from your feedback

Every inline comment now ends with a note inviting you to reply — replies feed back into Revvu's per-repo learning so future reviews match your team's conventions.

On-demand review triggers

Comment @revvu-ai review on any PR, click the Re-review button on the review detail page, or re-run the GitHub check — three ways to get a fresh review whenever you want one.

Feedback page in the dashboard

Submit bug reports, feature requests, and improvement ideas with optional star ratings. Browse your past feedback in a slide-out drawer.

Richer learnings context

The Learnings tab now shows the full memory behind each convention the AI has picked up — so you can see exactly why it flags (or skips) certain patterns.

More accurate line suggestions

Review comments now point to the correct line in your diff. A line-numbering fix eliminated off-by-one errors that could place suggestions on the wrong line.

Learnings no longer appear empty

Fixed a bug where the Learnings tab showed no results even after teaching the AI your conventions through feedback.

Reviews respect your project's coding standards

The AI now reads your project's CLAUDE.md, .cursorrules, tsconfig.json, and ESLint config to understand your team's conventions. It flags violations as warnings — no more suggestions that contradict your own rules.

Import-aware code understanding

Reviews now fetch the types and interfaces imported by changed files. The AI can verify that your code uses the correct type signatures, function parameters, and interface contracts — catching real bugs that require cross-file context.

Smarter confidence scoring

Confidence scores are now calibrated with clear anchor points, from 'provably wrong' (10) to 'possible concern' (5-6, not reported). This reduces noise and ensures every comment is worth your attention.

Automatic context budget management

For large PRs with lots of context, the AI now intelligently trims lower-priority context to stay within limits — your diff and project rules always fit, while nice-to-have context degrades gracefully.

Per-repo learning from feedback

Reply to any bot review comment to teach the AI your team's conventions. Future reviews on that repo will respect what you've taught it — fewer repeated suggestions, more relevant feedback.

Learnings dashboard tab

A new Learnings tab on each repo's detail page shows everything the AI has learned from your team's feedback, so you can see exactly what conventions it knows about.

Analytics dashboard with KPI cards and charts

See total reviews, success rate, average review time, issues found, and comments per review — all with trend comparisons against the previous period.

Review volume and severity visualizations

Interactive charts show daily review volume, severity breakdown, top issue categories, and file hotspots so you can spot patterns quickly.

Smart attention alerts

The dashboard highlights failed reviews, critical issue spikes, and repos with unusually high issue rates so you know where to focus.

Global dashboard filters

Filter all dashboard widgets by date range, repository, or review status. Filters are URL-driven so you can bookmark and share specific views.

Resolved threads auto-collapse

When you fix an issue the AI flagged, the conversation thread now automatically collapses in the PR — keeping your PR clean without manual dismissal.

Smarter repeat review accuracy

The AI now understands which comments are new vs. already addressed, significantly reducing duplicate comments and false 'resolved' notifications on repeat pushes.

Comments on unchanged files no longer marked resolved

Previously, pushing unrelated changes could falsely resolve comments on files you didn't touch. This is now fixed.

Incremental reviews

Push again and only new issues are posted. Previously flagged issues that you've fixed get a 'Resolved' reply instead of cluttering the PR with duplicates.

Reviews appear as CI status checks

Revvu now shows up in your PR's checks tab — you can see the review is in progress and whether it passed or found issues, just like any other CI tool.

AI summary in PR description

Each review adds a summary block to your PR description with the key findings. It updates in-place on subsequent reviews so you always see the latest status.

Redesigned dashboard

New collapsible sidebar, Cmd+K search to quickly find repos and reviews, breadcrumb navigation, and loading states across all pages.

Multi-line code suggestions

Review comments can now reference multi-line code blocks instead of single lines, giving more accurate context for suggestions.

Pricing page with plan comparison

Compare Free, Pro, and Enterprise plans side-by-side with a monthly/yearly toggle. See exactly what you get at each tier.

FAQ section

Answers to common questions about how Revvu works, supported languages, security practices, and getting started.

Security details

New section explaining how your code is handled — diffs processed in-memory, never stored, all webhooks cryptographically verified.

Context-aware reviews

The AI now considers the author's experience with the codebase, file ownership history, and surrounding source code — not just the diff. This produces more relevant and less generic feedback.

Review attempt tracking

The dashboard now shows how many times each PR has been reviewed, so you can track progress across pushes.

Repository removal synced to dashboard

Removing a repository from the GitHub App installation now immediately reflects in the dashboard instead of showing stale data.

Repository and review management

Browse all connected repos, view detailed review history with severity breakdowns and category filters, and drill into individual comments with the AI's reasoning.

Per-repo settings

Configure which files to ignore (e.g., generated code, lock files) and toggle auto-review on or off per repository.

Higher quality comments

Low-confidence findings are filtered out before posting, and comments now include formatted code blocks, severity badges, and structured reasoning.

No API key setup needed

Revvu is fully managed — you don't need to bring your own LLM API key. Just install the GitHub App and reviews start automatically.

Automatic PR reviews

Install the Revvu GitHub App on any repository. Every pull request and subsequent push triggers an AI review with inline comments — no configuration needed.

Severity-rated inline comments

Review findings are posted directly on the PR as inline comments with severity levels: critical, warning, suggestion, and nitpick. Critical issues are surfaced first.

Dashboard overview

See total reviews, success rate, average review time, and active repos at a glance. A recent activity feed shows what's been reviewed across all your repositories.

Secure by default

Your code is never stored. Diffs are processed in-memory and discarded after the review. All webhook payloads are cryptographically verified before processing.