Code Review Bots Read Diffs. This One Commits Fixes.
Comment @openreview on a GitHub PR. Claude spins up in an isolated sandbox, clones the branch, installs your dependencies, runs your linters and test suite, posts inline suggestions as GitHub suggestion blocks — and if it made fixes, commits them directly to the branch. React 👍 to apply. React 👎 to skip.
That's Vercel OpenReview, open-sourced this week. And it breaks the pattern of every other AI code review tool on the market.
The Problem With Every Other Tool
CodeRabbit. PR-Agent. Ellipsis. GitHub Copilot code review. They all work the same way: read the diff, pattern-match against known issues, post text suggestions. The AI sees what changed. It doesn't run anything.
That constraint matters more than it sounds. A linting suggestion is easy to generate from a diff — the model knows ESLint rules. But whether that fix actually passes when ESLint runs against your config with your version of Node? That requires execution. Read-only tools guess. They guess well, but they guess.
The deeper gap: they can't verify. A suggestion that looks correct in the diff might break an import two files away. A formatting fix might conflict with a Prettier config you've customized. Without running the code, there's no way to know.
OpenReview runs the code.
How the Execution Loop Works
The full flow, end to end:
Developer: @openreview in PR comment
↓
GitHub webhook fires
↓
Vercel Workflow starts (durable, resumable)
↓
Vercel Sandbox spins up (isolated VM)
↓
Sandbox: clone repo on PR branch → npm install
↓
Claude agent: review diff + explore codebase + run linters
↓
Fixes found → commit + push to PR branch
↓
Post inline GitHub suggestion blocks
↓
Sandbox destroyed
↓
Developer: 👍/❤️ to apply, 👎/😕 to skip
The sandbox is key. The agent isn't running in a shared container — it gets a fresh isolated VM per review. Your code runs in an environment that matches your repo's setup. The sandbox is destroyed when the review completes. No state leaks between PRs.
Why Sandboxed Execution Changes Everything
A read-only review tells you what might be wrong. An execution-based review tells you what is wrong — because the linter ran, the tests ran, and the output is deterministic. The difference between a suggestion and a verified fix.
Progressive Skill Loading
OpenReview ships with seven built-in review skills. Each one is a SKILL.md file with YAML frontmatter describing when it applies and what it checks:
| Skill | What It Reviews |
|---|---|
next-best-practices |
File conventions, RSC boundaries, async APIs, error handling |
next-cache-components |
PPR, use cache, cacheLife, cacheTag |
next-upgrade |
Migration guides and codemods |
vercel-composition-patterns |
React composition and component design |
vercel-react-best-practices |
Performance optimization patterns |
vercel-react-native-skills |
React Native and Expo best practices |
web-design-guidelines |
UI review, accessibility, Web Interface Guidelines |
The agent doesn't load all seven into the context window at once. It sees skill names and descriptions only, then calls loadSkill when a skill is relevant to what it's reviewing. This keeps the context lean — the agent has breadth of capability without paying the context cost upfront.
Add custom skills by dropping a SKILL.md into .agents/skills/<name>/. The agent discovers them at runtime. No config changes, no redeployment.
Durable Workflows, Not Timeouts
Most webhook-based automations die on large codebases. A review that takes 8 minutes hits a Lambda timeout. A flaky network call kills the run with no recovery path. You get a half-finished comment thread and no way to know what the agent was doing when it stopped.
OpenReview is built on Vercel Workflow — durable, resumable execution. If the review takes 15 minutes, it takes 15 minutes. If a call fails mid-review, the workflow resumes from the last checkpoint. No timeout management, no retry logic to write.
This is table stakes for production reliability, and essentially absent from DIY setups.
How It Compares
| Tool | Runs Code | Commits Fixes | Self-Hosted | Cost |
|---|---|---|---|---|
| OpenReview | ✓ | ✓ | ✓ | Free (your API costs) |
| CodeRabbit | ✗ | ✗ | ✗ | $19/mo per user |
| PR-Agent (Codium) | ✗ | ✗ | ✓ | Free / Pro |
| Ellipsis | ✗ | ✗ | ✗ | SaaS pricing |
| GitHub Copilot Review | ✗ | ✗ | ✗ | Included in Copilot |
The execution + commit combination is the real differentiator. OpenReview is closer to a coding agent that happens to live in GitHub than a code review tool. That's a category difference, not a feature gap.
The Skill Pattern Is Worth Stealing
The most transferable idea here isn't the sandbox or the workflow runtime. It's the progressive skill loading architecture.
The agent's system prompt contains skill names and descriptions — not full instructions. When the agent determines a skill applies, it calls loadSkill, reads the full SKILL.md, and proceeds with that context loaded. Skills that aren't relevant never touch the context window.
This is the same principle behind how we structure agent capabilities in OpenClaw — skills available but not pre-loaded. The constraint it solves: agents that know how to do 20 things shouldn't pay the context cost of 20 sets of instructions on every run. Load what you need, when you need it.
The custom skill mechanism makes this extensible without touching the core. Add .agents/skills/security-scan/SKILL.md with a YAML description and the agent discovers it. Version-control the skill. Review it like code.
Setup in 5 Steps
Fork + deploy to Vercel → create GitHub App → set ANTHROPIC_API_KEY and GitHub App env vars → install GitHub App on target repos → comment @openreview on any PR. Optional: add REDIS_URL for persistent state across reviews.
What It Means for Small Teams
For a team of one or two engineers, AI-assisted code review is effectively free senior review on every commit. The economics are different from a 20-person engineering org — you don't have a senior engineer with spare cycles to review every PR thoroughly. You have the person who wrote it doing self-review.
OpenReview changes that math. Drop it on your repos. Every PR gets reviewed by Claude before merge — linters run, patterns checked, fixes committed. The engineer still makes the final call (👍/👎). The mechanical parts are handled.
The "AI-reviewed code" signal is also table stakes for any developer-facing product in 2026. Customers and contributors expect it. OpenReview is MIT-licensed and self-hosted — you control what runs and what gets posted.
The Broader Pattern
OpenReview is one data point in a larger shift: AI agents that act rather than advise. The read-only suggestion is a transitional form — it exists because execution was hard to sandbox safely at low cost. Vercel Sandbox makes that cost low. Durable workflows make it reliable.
The next generation of developer tools won't post suggestions. They'll open PRs, commit fixes, run migrations, and hand off to human review with proof of work attached. OpenReview is an early example of what that looks like at the code review layer specifically.
"A suggestion you have to apply manually is a task in disguise. A verified fix you approve with a reaction is a different category of work."
The distinction matters more as the volume scales. On a repo with 50 PRs a week, manually applying 200 lint suggestions is work. Reacting 👍 to 200 verified commits is a different workflow.
Worth deploying. Worth studying the architecture. The skill system alone has patterns worth adapting for any agent that needs to manage capability breadth without context bloat. ☕