---
title: "Review code you don't trust with Open Code Review on a sealed VM"
description: "Run Alibaba's Open Code Review on a throwaway exe.dev VM cut off from the internet: copy a review box, clone the code, read the report, delete it."
url: https://exe.dev/deploy/open-code-review
category: "Security"
updated: 2026-11-16
---

# Review code you don't trust with Open Code Review on a sealed VM

An AI code reviewer in a box you copy, seal, and throw away.

- **Software:** Open Code Review (https://open-codereview.ai)
- **Source:** https://github.com/alibaba/open-code-review
- **License:** Apache-2.0
- **Time:** 5 minutes, then 2 minutes per review
- **Example VM name:** `my-open-code-review` (yours will differ; on the VM, `hostname` prints it)
- **Machine-readable:** https://exe.dev/deploy/open-code-review/manifest.json

## What you get

- Node.js 24 and Open Code Review 1.13 installed
- Open Code Review using exe.dev's LLM integration, with no model key on the VM
- A connection test that ends with `✓ Tool-call round trip verified`
- No code on the VM; reviews run on copies

Running on the VM:

- **Open Code Review**: @alibaba-group/open-code-review 1.13 on Node.js 24, data in `~/.opencodereview`
- **Review copies**: one copy of my-open-code-review per review, with internet access cut, deleted afterwards, data in `~/code and ~/reviews on each copy`

How it is reached:

- ssh my-open-code-review.exe.xyz (private): the review box you copy; nothing to review is kept here
- http://localhost:5483/ through an SSH tunnel (private): Open Code Review's session viewer, on a copy

## Deploy with Shelley

Open https://exe.dev/new?prompt=Set%20up%20Open%20Code%20Review%20on%20this%20VM%20by%20following%20the%20exe.dev%20recipe%20at%20https%3A%2F%2Fexe.dev%2Fdeploy%2Fopen-code-review.md%20from%20top%20to%20bottom.%0A%0AThe%20recipe%27s%20example%20VM%20name%20is%20my-open-code-review.%20This%20VM%27s%20name%20is%20the%20output%20of%20%60hostname%60%3A%20use%20it%20wherever%20the%20recipe%20writes%20my-open-code-review.%20Skip%20the%20step%20that%20creates%20the%20VM%3B%20you%20are%20on%20it.%0A%0AYou%20are%20done%20when%20all%20of%20these%20are%20true.%20Check%20each%20one%20yourself%3A%0A-%20Node.js%2024%20and%20Open%20Code%20Review%201.13%20installed%0A-%20Open%20Code%20Review%20using%20exe.dev%27s%20LLM%20integration%2C%20with%20no%20model%20key%20on%20the%20VM%0A-%20A%20connection%20test%20that%20ends%20with%20%60%E2%9C%93%20Tool-call%20round%20trip%20verified%60%0A-%20No%20code%20on%20the%20VM%3B%20reviews%20run%20on%20copies%0A%0ARun%20the%20commands%20in%20%22Install%20by%20hand%22%2C%20from%20%22Install%20Open%20Code%20Review%22%0Aon%2C%20and%20the%20check%20at%20its%20end.%20Don%27t%20clone%20or%20review%20any%20code%20on%20this%0AVM%3A%20it%20is%20the%20template%20the%20owner%20copies%20for%20each%20review.%20Finish%20by%0Atelling%20the%20owner%20to%20follow%20%22Review%20a%20repository%22%20from%20their%20computer.%0A%0AFinish%20with%20the%20URLs%20I%20should%20open.%0A to create a VM whose agent, Shelley, follows this recipe. From a terminal:

```sh
curl -fsSL https://exe.dev/deploy/open-code-review/prompt.txt | ssh exe.dev new --prompt=/dev/stdin
```

Or follow the steps below by hand.

[Open Code Review](https://github.com/alibaba/open-code-review) is
Alibaba's open-source AI code reviewer (Apache-2.0). It reviews a diff or
whole files with an agent that can read and search the repository, and
reports comments with a severity, a category such as security or bug,
and an exact line. It comes as a CLI, an MCP server, a GitHub Action, and
plugins for Claude Code, Codex, Cursor and others. Version 1.13.9 came
out on November 13, 2026.

This page uses it for code you don't trust yet: a dependency you're
about to add, a contractor's branch, a repository someone sent you. The
VM is a review box you set up once. For each review you copy it, clone
the code into the copy, cut the copy off from the internet, review, and
delete it. The model comes from exe.dev's
[LLM integration](/docs/integrations-llm), so no API key is on any of
the VMs.

## Install

On exe.dev, click **Deploy** to have Shelley set it up on a new VM. Or
create it yourself:

<details class="dp-details" id="create-the-vm" data-manual-setup>
<summary>Install by hand</summary>

On your computer:

```bash
ssh exe.dev new --name=my-open-code-review
ssh my-open-code-review.exe.xyz
```

### Install Open Code Review

On the VM, install Node.js 24 and Open Code Review:

```bash
curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
sudo apt-get install -y nodejs
sudo npm install -g @alibaba-group/open-code-review
ocr --version
```

### Connect it to the LLM integration

On the VM, add a provider for exe.dev's LLM integration. The key is a
placeholder that Open Code Review insists on; the integration adds the
real credentials at exe.dev's edge:

```bash
ocr config set provider exe-llm
ocr config set custom_providers.exe-llm.url https://llm.int.exe.xyz
ocr config set custom_providers.exe-llm.protocol anthropic
ocr config set custom_providers.exe-llm.model claude-sonnet-5-5
ocr config set custom_providers.exe-llm.api_key exe-gateway
```

### Check the setup

On the VM:

```bash
ocr llm test
```

It ends with `✓ Connection test successful` and
`✓ Tool-call round trip verified`.

</details>

Keep this VM clean: no code, no GitHub integrations, no tags. Every
review starts as a copy of it, and a copy keeps the files, the tags, and
any integration attached by tag.

## Review a repository

On your computer, copy the box, clone the code into the copy, then cut
the copy off from the internet:

```bash
ssh exe.dev cp my-open-code-review review-1
ssh review-1.exe.xyz git clone --depth=1 https://github.com/someone/package.git code
ssh exe.dev egress review-1 integrations
```

With the [egress policy](/docs/internet-access) at `integrations`, the
copy can reach exe.dev's integrations, the LLM one included, and nothing
else. Then review every file:

```bash
ssh review-1.exe.xyz 'cd code && ocr scan'
```

A small library takes under a minute. Each comment names the file and
lines, a category and a severity, then explains the problem and the fix,
and a project summary at the end groups what it found. For instance,
from a review of `pallets/itsdangerous`:

```
─── src/itsdangerous/url_safe.py:53-53 ───
[bug · medium] The `serializer` override accepted by this method is silently discarded. This breaks
the documented `Serializer.load_payload(..., serializer=...)` contract for URL-safe serializers
...
```

For a large repository, start with the parts that matter, such as
`ocr scan --path src/auth,src/api`, and `ocr scan --preview` lists the
files a scan would read without calling the model. To keep the results,
write them as JSON and copy them out:

```bash
ssh review-1.exe.xyz 'cd code && ocr scan --format json --output ~/review.json'
scp review-1.exe.xyz:review.json ./review-1.json
```

When you're done, delete the copy:

```bash
ssh exe.dev rm review-1
```

Code on your computer goes in with `rsync -a ./package/ review-1.exe.xyz:code/`
instead of the clone. Prefer a fresh clone, though: a `.git/config` from
someone else can run commands when git reads it, and Open Code Review
runs git.

## Browse the review

Open Code Review keeps each review as a session and has a viewer for
them, where you can read comments next to the code and mark them fixed
or ignored. On your computer, start it on the copy with a tunnel:

```bash
ssh -L 5483:localhost:5483 review-1.exe.xyz 'cd code && ocr viewer --open=never'
```

Then open http://localhost:5483/. Ctrl-C stops it.

## Add Codex Security

Open Code Review is a broad, fast reviewer. For a deeper security pass,
OpenAI's [Codex Security](/deploy/codex-security) writes a threat model
and traces each finding from input to sink; it takes a few minutes and
costs about $0.35 for a small library. To have it on every copy, install
it on the review box, with a profile for the LLM integration. On
`my-open-code-review`:

```bash
sudo npm install -g @openai/codex-security
mkdir -p ~/.codex
cat > ~/.codex/review.config.toml <<'EOF'
model = "gpt-5.6-terra"
model_reasoning_effort = "medium"
model_provider = "exe-llm"

[model_providers.exe-llm]
name = "exe.dev LLM integration"
base_url = "https://llm.int.exe.xyz/v1"
wire_api = "responses"
env_key = "EXE_LLM_KEY"
EOF
```

Then, on a sealed copy:

```bash
ssh review-1.exe.xyz 'cd code && EXE_LLM_KEY=exe-gateway cs scan . --codex "profile='\''review'\''" --headless --max-cost 5'
```

It prints the number of findings, the cost, and where its `report.md`
is.

## Use it on your own code

The same CLI reviews your own changes on any VM where you develop; add
the provider as in [Install](#create-the-vm). In a repository:

```bash
ocr review                            # staged, unstaged and new files
ocr review --from main --to my-branch # a branch, since it left main
ocr review --commit HEAD              # one commit
```

For every pull request, Alibaba's GitHub Action runs the review in CI
and posts the comments inline; its
[example workflow](https://github.com/alibaba/open-code-review/tree/main/examples/github_actions)
is ready to copy. With a provider key in your repository's secrets it
runs on GitHub's runners. On a
[self-hosted runner on exe.dev](/deploy/github-actions) it can use the
LLM integration instead, with no model secret in GitHub:

```yaml
- uses: alibaba/open-code-review@main
  with:
    llm_url: https://llm.int.exe.xyz
    llm_auth_token: exe-gateway
    llm_model: claude-sonnet-5-5
    llm_use_anthropic: "true"
```

Open Code Review also has plugins that let
[Claude Code](/deploy/claude-code), [Codex](/deploy/codex) and other
agents ask for a review; see its
[plugin guide](https://github.com/alibaba/open-code-review/blob/main/plugins/open-code-review/README.md).

## Update

On `my-open-code-review`:

```bash
sudo npm install -g @alibaba-group/open-code-review
ocr --version
```

Copies made after that get the new version.

## Troubleshooting

- **`ocr llm test` fails**: `cat ~/.opencodereview/config.json` shows
  the provider. The URL must be `https://llm.int.exe.xyz` with protocol
  `anthropic` for Claude models, and the key must not be empty.
- **`ocr: command not found` over ssh**: it was installed without
  `sudo`, into a directory only login shells see. Reinstall with
  `sudo npm install -g @alibaba-group/open-code-review`.
- **The copy can't reach the LLM integration after `egress`**:
  `curl -s https://llm.int.exe.xyz/v1/models` on the copy should answer.
  On a VM created before exe.dev moved DNS to `169.254.169.254`, run
  `echo "nameserver 169.254.169.254" | sudo tee /etc/resolv.conf` on
  `my-open-code-review` once.
- **`git clone` fails on the copy**: run it before
  `ssh exe.dev egress review-1 integrations`; afterwards only exe.dev's
  integrations are reachable.
- **A review stops partway**: `ocr session list` on the copy shows it,
  and `ocr scan --resume <session-id>` continues it.

## Frequently asked questions

### How much does a review cost?

The VMs are part of your exe.dev plan, and a copy lives only for a review. The model is billed to your exe.dev account through the [LLM integration](/docs/integrations-llm): reviewing all eight source files of a small Python library with `claude-sonnet-5-5` used about 125,000 tokens and took 23 seconds.

### Why a copy with no internet?

Open Code Review is an agent: it reads files and searches the repository with tools, and text in the repository can try to steer it. On a copy whose [egress](/docs/internet-access) is cut to exe.dev's integrations there is nothing to steal and nowhere to send it, and you delete the copy when you're done.

### Does it run the code it reviews?

No. It reads the code and asks the model about it; it doesn't build, install, or run anything from the repository. The sealed copy is for the cases where something tries anyway.

### Can I use it on my own pull requests?

Yes: `ocr review` reviews a diff, and Alibaba's GitHub Action posts the comments on each pull request. See [Use it on your own code](#use-it-on-your-own-code). For a bot that answers commands in pull requests, see [PR-Agent](/deploy/pr-agent).

### Can I use a different model?

Any model the LLM integration serves; set it with `ocr config set custom_providers.exe-llm.model`. Claude models use the `anthropic` protocol as on this page; for OpenAI models set the URL to `https://llm.int.exe.xyz/v1` and the protocol to `openai-responses`.


## Related

- [Scan your repositories with Codex Security every night](https://exe.dev/deploy/codex-security.md): Nightly AI security scans of your repositories, with no keys on the VM.
- [Self-host PR-Agent, the AI pull request reviewer, on exe.dev](https://exe.dev/deploy/pr-agent.md): Your own AI pull request reviewer, with no model key on the VM.
- [Sandboxes on exe.dev](https://exe.dev/deploy/sandbox.md): A VM with its own CPU and memory, billed by the second while it runs.
- [Run the Shannon AI pentester on a disposable VM](https://exe.dev/deploy/shannon.md): An AI pentester for your own web apps, in a VM you delete afterwards.
- [Run GitHub Actions jobs on exe.dev, a fresh VM per job](https://exe.dev/deploy/github-actions.md): Every job on a fresh copy of a warm VM, billed by the second.
- [Run Claude Code on a remote server](https://exe.dev/deploy/claude-code.md): A computer for Claude. A breather for your laptop.
