roborev: local, continuous code review for the agentic loop

Find bugs faster and ship better quality code. roborev is a review daemon on your machine. A git hook reviews each commit in the background with the agents you already run, while you keep working.
One Go binary, no runtime dependencies, MIT licensed. Install in one command.
A coding agent can land dozens of commits in an hour. Review still arrives at the pull request: once, late, after the agent has moved on and the reasoning that produced the bug is gone from its context. By then every finding is a context switch for a human. roborev moves review to the commit, runs it in the background on your own machine, and gives the result back to the thing that can fix it fastest.
Two automation layers close the loop. The post-commit hook reviews every commit with any agent or editor. The agent hook watches supported coding-agent sessions and, once review work piles up, delivers the exact review IDs to the roborev-fix skill before the session goes cold. Neither layer touches your working tree on its own.
Layer 1 · post-commit
roborev init installs the hook, starts the daemon, and registers the repo. Each commit gets a verdict and, when it fails, findings with severities and file locations. Set post_commit_batch_size to review a run of small commits as one range.
Layer 2 · agent hook
roborev agent-hook install wires Claude Code, Codex, Copilot CLI, Cursor, Factory Droid, Gemini CLI, Hermes, and Qwen. After a configurable number of turns, commits, or failed reviews, the agent is told which reviews to fix, by ID, and told to verify and close them.
/roborev-fix pulls every open failing review for the branch, fixes the valid findings, documents the invalid ones, and closes them. /roborev-refine reviews, fixes, commits, and re-reviews the whole branch until every review passes, before the PR exists.
roborev fix hands open findings to an agent that applies changes and commits. roborev refine runs the same iterate-until-green loop in an isolated worktree, with --max-iterations and --min-severity as the guardrails.
A review that scrolls past in a chat window is a review nobody is accountable for. roborev keeps every review in a persistent queue with a verdict, findings, the exact prompt, and the agent log. Open findings stay visible in the terminal UI and the browser UI until someone closes them, with a response on record if they disagree.
roborev orchestrates the agent CLIs already installed on the machine, so the reviewer can be a different vendor than the writer, a cheaper model than the writer, or a local model behind a proxy. Pick per repo, per workflow, and per reasoning level, and name a backup for when a quota runs out.
Config keys like review_agent_fast, fix_model_thorough, and security_backup_agent route each workflow (review, fix, refine, security, design) to its own agent, model, and reasoning level.
Transient failures retry. Exhausted retries or a quota error fail over to the backup agent. Rate-limited agents sit in a cooldown parsed from the provider's own reset message.
Per-repo review_guidelines in .roborev.toml (or a REVIEW.md) ride along on every review, with global guidelines layered underneath. Bound to a kata project? The task context comes too.
Point Claude Code at Ollama or LiteLLM with a model@base_url spec, or add any Agent Client Protocol adapter as a named agent. Reviews never require a hosted roborev service.
Risky changes deserve more than one opinion. A review panel fans one target out to named subagents, each with its own agent, review type, instructions, and timeout, then a synthesis agent merges them into one review. The same machinery runs security, design, and look-ahead-bias reviews, your own template-driven review types, and whole-codebase analysis.
Define [review.subagents.security] and friends once, group them into [review.panels.branch_final], and run roborev review --branch --panel branch_final. Optional members can flake without blocking the panel.
--type security, --type design, --type lookahead, and --type test-value swap the system prompt. Custom types wrap a Go template rubric in the same schema, severity filtering, and pass/fail verdict.
roborev analyze duplication ./..., plus complexity, dead-code, refactor, api-design, architecture, security, and test-fixtures. Findings land in the same queue; --fix applies them.
roborev compact re-checks open findings against the current code, drops the ones that no longer hold, and consolidates the rest into a single review before anyone spends time on them.
The daemon polls GitHub and GitLab for open pull and merge requests, runs one panel per PR head against the frozen merge-base range, and posts a single synthesized comment with the member reviewers, runtimes, and costs in the footer. Human discussion from trusted collaborators goes into the prompt; a fork's branch name never gets to pick which rules apply.
Install as a GitHub App so comments and checks appear as your-app[bot] with repository-scoped permissions, or use your gh login for a personal project. Each reviewed head gets a check.
Point the poller at GitLab projects and the synthesized review lands as an MR note, with quick-action escaping so an agent's output cannot drive the MR.
[ci].skip_labels exempts drafts and generated updates and reports a skipped check. Per-repo .roborev.toml overrides the panel, agents, and reasoning for one project without touching the rest.
The CI poller is the same roborev daemon under systemd or launchd on a box you own. It reviews on the interval you set, at the concurrency you set, with no per-seat pricing and no code leaving your network.
Every job records its agent, model, runtime, token usage, estimated cost, and outcome. The browser UI turns that into an analytics workspace; the exports turn it into your own dashboards; the experiments turn it into decisions about which configuration your team should actually run.
Filter by project, source, agent, model, or time range, with the filters encoded in the URL so a view can be shar