DIRTY STATIC / DISPATCH Tools15 NOV 2026 • 11 MIN READ
A conveyor pipeline of concrete blocks carrying printed code sheets past robotic inspector arms in a brutalist hall, one arm stamping a sheet with a caution yellow check, hazard stripes on the floor
ToolsINTELLIGENCE FOR THE MACHINE AGE

Open Code Review: Hybrid Pipelines Meet Agents

Open Code Review is an open source code review CLI from Alibaba, built as a hybrid: plain engineering code decides which files get reviewed, which rules apply, and where each comment lands, while a model agent reads context and judges the code. This profile covers how that split works, what its own AACR-Bench benchmark does and does not prove, the review, scan, and delegation modes, its integrations with coding agents and CI, and what it costs to run.

Start reading ↓

Ask a general purpose coding agent to review a large change and three failures show up again and again. It reviews some files and quietly skips others. It reports a real defect but pins the comment to the wrong line. And its quality swings when someone edits the prompt that guides it, so the same tool feels sharp one week and sloppy the next.

Open Code Review, a command line tool from Alibaba that runs as ocr, is built around a refusal to accept those failures as normal. The steps that must not go wrong run in ordinary code, with hard rules. The model is left with the one job it is actually good at: reading code in context and judging whether something is wrong.

Open Code Review

Official site

An AI code review CLI that began as the internal review assistant at Alibaba Group. Primary use case: reviewing Git changes and whole files with comments pinned to exact lines, in a terminal, in CI, or inside a coding agent you already use.

Key features: precise file selection and filtering in code; smart bundling that groups related files into one review unit, with each bundle run by a sub agent in isolated context; rule matching by template, with an included ruleset that covers classes of defect such as null pointer faults, thread safety faults, XSS, and SQL injection; separate positioning and reflection modules that check where comments land and what they say; a scan mode for whole files; and structured output, including JSON.

Advantages: the review process is stable by construction, the tool works with OpenAI and Anthropic compatible endpoints, and the project publishes its benchmark data set in the open. Limitations: recall is lower than a general purpose agent by design, every headline benchmark figure comes from the project itself, and you still pay model costs on each review unless you delegate.

Platforms
Windows, macOS, and Linux; CLI, plus plugins for Claude Code, Codex, Cursor, Kimi Code, and OpenCode, and CI recipes for GitHub Actions, GitLab CI, GitFlic CI, and Gerrit
Pricing
Free and open source under Apache 2.0; you pay the model provider you configure, or use Delegation Mode and let a host agent supply the model
The provider setup screen in Open Code Review, where a user picks a model provider and model before a review
Provider setup comes first: pick a provider, add a key, pick a model, and the tool tests the connection. Image: Open Code Review project

What it is

Open Code Review is written in Go and installed with one npm command, with an install script, release binaries, and a build from source as other routes. It needs Git 2.41 or newer, because Git supplies the diffs, the code search, and the repo operations the tool runs on.

The project says the tool served as the official AI review assistant inside Alibaba Group for two years before it was released as open source, serving tens of thousands of developers and finding millions of defects. Treat those figures as the project account of its own internal history. They explain why the design looks the way it does, and they cannot be checked from outside Alibaba.

In daily use the shape is simple. Run the tool inside a repo and it reads the diff, works out which changed files merit review, and returns structured comments tied to specific lines. The agent behind those comments can read a full file, search the codebase, and inspect other changed files, so a comment can rest on context outside the diff itself. That matters, because many real defects only look like defects when you can see the caller, the sibling file, or the second half of a change.

The hybrid is the whole argument

Most AI review tools are a prompt with a tool belt. Open Code Review splits the work into two layers and is explicit about which layer owns which job.

The deterministic layer owns the steps that must not drift. It decides exactly which files need review and which get filtered out. It bundles related files into a single review unit; the project example pairs message_en.properties with message_zh.properties, two language files that belong in the same review. It matches rules to each file through a template engine rather than through prose in a prompt. And after the model writes, separate modules handle comment positioning and reflection, checking the location and the content of each comment before it reaches you.

Each bundle then runs as a sub agent with isolated context. A very large change is divided into units that can be reviewed at the same time, and one sprawling file cannot crowd the rest of the change out of the window. This is the direct answer to the skipped file problem: coverage is decided by code that counts files, not by a model that gets tired.

The agent layer owns judgement. Its prompts are tuned for review work, and its toolset was distilled, per the project, from tool call traces in large scale production data: how often each tool was called, how often calls repeated, and what new tools did to the chain. Whether that tuning is as strong as claimed is hard to test from outside, but the direction is sound. A tool built for one job should behave better than a general tool handed that job as an afterthought.

Our profile of Kilo Desktop made a similar point about workbenches. The durable value sits in the structure around the model. Open Code Review applies that idea to review: keep the model, discipline everything around it.

What the benchmark shows, and what it does not

The project built its own benchmark to back the design, called AACR-Bench. It holds 200 real pull requests from 50 popular open source repos, across 10 programming languages, with 1,505 ground truth issues cross validated by more than 80 senior engineers. The data set is published on Hugging Face, so anyone can inspect what was measured.

Against a general purpose agent, Claude Code, using the same underlying model, the project reports significantly higher precision and F1, faster reviews, and token use at about one ninth of the general agent run. Precision is the share of reported issues that are real defects. F1 balances precision against recall. Recall is the share of real defects a tool finds, and here Open Code Review scores lower, which the project calls a deliberate trade: fewer false alarms, at the cost of finding fewer of the real issues in a change.

Tokens per review, relative scale

General purpose agent100 units
Open Code ReviewAbout 11 units

Relative token use reported by the project on AACR-Bench, same underlying model. Project figures, checked November 15, 2026.

The AACR-Bench results chart published by the Open Code Review project, comparing precision, recall, F1, time, and token use against a general purpose agent
The project benchmark chart: higher precision and F1, lower recall, and far lower token use than a general purpose agent on the same model. Image: Open Code Review project

Modes for the terminal, the agent, and the pipeline

The default mode reviews a change. Workspace mode covers staged, unstaged, and untracked work. A branch range mode reviews what a branch changed since it split from its base, and a commit mode reviews one commit. Sessions can be listed and resumed, which matters when a large review is cut off midway.

Terminal

npm install -g @alibaba-group/open-code-review
ocr config provider
ocr config model
ocr review
ocr review --from main --to feature-branch
ocr scan --path internal/agent

Scan mode drops the diff entirely and reviews whole files. That is the mode for an unfamiliar codebase, an audit of one directory, or a repo where the change history tells you nothing useful. Results can be saved as JSON, which is the form a host agent or a CI job can act on without scraping terminal text.

Delegation Mode is the other route in. Instead of configuring a model inside the tool, you let your coding agent run the review with its own model, while Open Code Review supplies the file selection and the rules. No separate key for the tool is needed in that mode. Plugins and skills carry the tool into Claude Code, Codex, Cursor, Kimi Code, and OpenCode, and the docs cover CI recipes for GitHub Actions, GitLab CI, GitFlic CI, and Gerrit. A session viewer lets you browse and replay reviews in a browser and mark comments as fixed or ignored, and telemetry hooks follow the OpenTelemetry standard.

This spread of entry points is the practical strength of the project. A solo developer can run it in a terminal before a push. A team can pin it in CI so every pull request gets the same first pass. A team already settled on a coding agent can delegate, keeping its model account and gaining the file selection and rule discipline. Our tutorial on running several coding agents side by side covers why that kind of shared structure matters once agent use stops being a novelty.

What Works

  • Coverage, bundling, and rule matching decided in code, so large changes do not get skimmed
  • Comments pinned and checked by separate positioning and reflection modules
  • Review, scan, and delegation modes cover the terminal, audits, and host agents
  • Free and open source, with OpenAI and Anthropic compatible endpoints and a public benchmark data set

What Does Not

  • Lower recall by design, so real defects will pass a clean review
  • All headline benchmark figures are project reported, with no independent run found
  • Model costs remain yours on each review in the default mode
  • Included rules vary by language, and some language rule files lack a security section

Which should you choose

Choose Open Code Review if review noise is your problem. If your current AI reviewer floods a pull request with comments your team has learned to ignore, a tool tuned for precision is the right correction. A short list of comments that are mostly real will get read. A long list that is mostly noise trains everyone to skip the list.

Choose it if you review large changes. Bundling and isolated sub agents were built for changes that overflow one context window. Small changes gain less, because a general agent can hold a small change whole without help.

Choose delegation if your agent is already chosen. Teams settled on Claude Code, Codex, or Cursor keep their model, their account, and their habits, and add file selection and rules they did not have. That is a cheaper change than swapping agents to chase a benchmark.

Look elsewhere if missing a defect costs more than triage does. Security audits and safety critical code need recall first. In those settings a noisy reviewer plus human triage, or this tool plus a second pass from another reviewer, fits the risk better than a quiet first pass alone. Treat a clean result here as a good sign, never as proof.

Look elsewhere if you want a hosted service with no setup. This is a CLI you install, configure, and keep current yourself, with a model account of your own behind it. Teams that want a vendor to own all of that will prefer a hosted review product and will pay for the privilege.

Final thoughts

Open Code Review is an argument about where intelligence belongs in a tool. Its answer is unfashionable and persuasive: most of the process should not be intelligent at all. Counting files, grouping them, matching rules, and placing comments are jobs for code that does the same thing every time. Judgement is the scarce resource, and the model should spend all of its effort there.

That discipline buys quieter reviews and a much smaller token bill, and it costs recall, which the project admits in plain language. For most teams drowning in review noise, that is the right trade to try first, and the price of trying it is an install command and one honest comparison on your own pull requests.

Sources

■

END OF TRANSMISSION

Stay curious. Question everything.

CONTINUE THE DESCENT

MORE FROM DIRTY STATIC ↘