roborev
roborev
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.
$ roborev init
Ready! Every commit will now be automatically reviewed.
$ git commit -m "Add retry to payment webhook"
$ roborev show HEAD # later, whenever you want it
Review for 8f2c1a0 (job 214, by codex)
------------------------------------------------------------
## Review Findings
- **Severity**: High
- **Location**: `internal/webhook/retry.go:41`
- **Problem**: A timeout after the POST was delivered retries it, so the
webhook can be charged twice. Nothing makes the request idempotent.01 / The gap
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.
02 / The loop
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.
Skills
/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.
Headless
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.
03 / The ledger
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 tui: the queue and the selected review, side by side, with vim keys.
roborev ui: the browser workspace, served by the same daemon over the same SQLite history.04 / Agents
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.
Routing
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.
Failover
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.
Guidelines
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.
Anywhere
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.
05 / Depth
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.
Panels
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.
Review types
--type security, --type design, and --type lookahead swap the system prompt. Custom types wrap a Go template rubric in the same schema, severity filtering, and pass/fail verdict.
Analysis
roborev analyze duplication ./..., plus complexity, dead-code, refactor, api-design, architecture, security, and test-fixtures. Findings land in the same queue; --fix applies them.
Verification
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.
06 / Pull requests
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.
GitHub
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.
GitLab
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.
Control
[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.
Runs anywhere
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.
07 / Visibility
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.
Analytics
Filter by project, source, agent, model, or time range, with the filters encoded in the URL so a view can be shared. roborev cost, summary, and insights give the same numbers on the command line.
Exports
roborev export reviews, ci-metrics, and ci-costs emit stable, resumable JSON for review turnaround, CI outcomes, and job-level spend. A metadata profile keeps review text out when you only need the numbers.
Experiments
Assign branches to a default or experimental group and roborev keeps each branch in its group across local and CI reviews. roborev config validate checks an experiment before it runs a single review.
Events
[[hooks]] run shell commands on review events: desktop notifications, Slack, webhooks. Built-in kata and beads hooks file findings as tracked issues, scoped to the branches you name.
08 / Ownership
The daemon runs on your machine, reads your repo, and writes to a SQLite database under ~/.roborev. Nothing leaves except the calls your agents already make. Turn on PostgreSQL sync and every machine keeps its local database while the team's review history converges in one place, deduplicated by UUID.
review, show, fix, refine, analyze, list, and --json where scripts need it.ROBOREV_TELEMETRY_ENABLED=0.
09 / Boundary
Hosted review bots read your code from someone else's cloud, once, when the pull request opens. Human review is still the gate, and it should be. roborev is the layer in between: continuous, local, running on the agents you already pay for, so what reaches the PR has already been reviewed and fixed several times over.
Hosted PR bot
Arrives at the pull request. Another vendor with read access to your repositories, another per-seat bill, and findings that land after the agent's context is gone.
Human review
The most expensive attention on the team, spent once per PR. Save it for design and intent. The retry loop that re-sends a POST should never reach it.
roborev
Per commit, on your machine, with your agents. Findings go back to the agent that can fix them now, and the ledger says what is still open when a human finally looks.
10 / Start
The guide walks the loop from roborev init to CI panels and team-wide history. The docs carry every command, configuration key, and integration. roborev quickstart prints the setup guide for your coding agent to finish itself.
curl -fsSL https://roborev.io/install.sh | bash
brew install kenn-io/tap/roborev
powershell -ExecutionPolicy ByPass -c "irm https://roborev.io/install.ps1 | iex"
See all install options.
