# arnx

> arnx is an open-source AI code review CLI for coding agents. It investigates code changes, generates and executes tests for suspected bugs in Docker, compares behavior before and after the change, and lets developers retain accepted tests as regression checks.

- Latest release: arnx 0.1.11 (checked 2026-11-12). Apache License 2.0.
- Install: `npm install -g @arnx-dev/arnx` (Node 20 or later), or a standalone binary from GitHub Releases. Docker must be running. macOS and Linux; Windows through WSL 2.
- Languages and runners: Python (pytest); JavaScript and TypeScript (vitest, jest, node:test, bun); Rust (cargo-nextest, early). Go support is in test and not released.
- CLI workflow: `arnx init`, `arnx review`, `arnx triage`, `arnx accept`, `arnx prompt`, `arnx check`. "Pre-commit" here means the point in the workflow before you commit or open a pull request, not a Git pre-commit hook.
- Agent Skill: `arnx skill install` writes `.agents/skills/arnx/` and `.claude/skills/arnx/`. The agent runs one review and the fix loop; init, logins, triage, accept and commits stay with the developer.
- Cost: with your own keys you pay providers directly. Each review stops writing tests at `review_usd` (default $3.00). `arnx check` makes no model calls.
- Data: tests run in local Docker. The diff, files the reviewer reads, generated tests and their output go to your model providers, or to arnx Cloud when you choose it (it asks consent once per repository).
- Limits: changes up to 200 KB per review; works best on single-package Python and TypeScript repositories; tests that run only in a browser are not run; a failing generated test shows an assertion fails, not that the code is wrong; model replies vary between reviews.

## Start here
- [Quickstart](https://arnx.dev/quickstart.html): install, first review, Cloud, the agent skill, costs and common failures.
- [For coding agents](https://arnx.dev/agents/): when an agent should use arnx, what needs human approval, and the fix loop.
- [Product](https://arnx.dev/product.html): what a finding and a check mean.
- [Source code](https://github.com/arnx-dev/arnx): the Apache-2.0 CLI.
- [Agent Skill (SKILL.md)](https://github.com/arnx-dev/arnx/blob/main/skills/arnx/SKILL.md): the instructions an agent follows.
- [Checkout demo](https://github.com/arnx-dev/checkout-demo): a small public repository with a labelled planted bug to review.
- [Security and data boundaries](https://arnx.dev/security.html): what runs locally and what is sent.

## Guides
- [AI code review: comments versus executable evidence](https://arnx.dev/guides/ai-code-review/): What AI code review is, how comment-based and evidence-based review differ, where each fits, and how to judge a tool.
- [Keeping regression tests from AI review findings](https://arnx.dev/guides/ai-regression-testing/): Turning a confirmed finding into a retained regression test: what to read first, where the test lives, and how edits are detected.
- [How to review code written by Claude Code](https://arnx.dev/guides/claude-code-review/): Claude Code's own review commands, what they do not run, and how to add tests that execute through the arnx plugin or skill.
- [How to review code written by Codex](https://arnx.dev/guides/codex-code-review/): Reviewing Codex's changes with tests that run: where Codex reads the arnx skill, what we have and have not tested, and a manual flow for any agent.
- [AI code review before you commit or open a pull request](https://arnx.dev/guides/pre-commit-ai-code-review/): Reviewing before the commit or pull request: what gets reviewed, why not a Git hook, and the cheap check you can repeat in CI.
- [How to verify AI-generated code](https://arnx.dev/guides/verify-ai-generated-code/): A verification checklist for agent-written code and the four levels of evidence, from a failing assertion to a violation of intended behavior.

## Case studies
- [arnx self-review: remove could delete files outside the repository](https://arnx.dev/case-studies/arnx-self-review/): arnx reviewing its own code: a generated test showed arnx remove would delete a file outside the repository. The test still guards that behavior in the public source.
- [beets: shell completion crashed with the titlecase plugin](https://arnx.dev/case-studies/beets/): A generated test showed a plugin added the same command-line option twice, which crashed shell completion. Fix open upstream, not merged; most other findings in the review were intended behavior.
- [Hummingbot: order statuses paired with the wrong order](https://arnx.dev/case-studies/hummingbot/): One finding sent upstream as an open pull request, and a separate set of findings that matched fixes the maintainers had already made on their own. arnx caused none of those fixes.
- [mark: a second Close returned before shutdown finished](https://arnx.dev/case-studies/mark/): A generated test showed a second concurrent Close returned while the resource was still stopping. Fix merged upstream. Found with Go support that is in test and not released.
- [SQLFluff: valid ClickHouse projections were unparsable](https://arnx.dev/case-studies/sqlfluff/): A generated test showed valid ClickHouse projection SQL was rejected by the parser. Fix merged upstream; arnx's one confirmed finding in the same review was wrong.
- [A private Python and Postgres review](https://arnx.dev/case-study.html): an owner-run workflow example, not a benchmark.

## Research
- [Why a failing test is not sufficient evidence of a bug](https://arnx.dev/research/failing-test-not-a-bug/): Four levels of evidence, from a failing assertion to a violation of intended behavior, with counts from one graded batch and two public examples.
- [Can a second LLM judge code review findings?](https://arnx.dev/research/second-model-judge/): In one batch, a second model's dispute was right 22 of 23 times; its confirmation held 12 of 36 times. Read the two verdicts differently.
- [AI code review findings on unfamiliar repositories](https://arnx.dev/research/unfamiliar-repositories/): 65 graded findings from 18 reviews of 12 repositories new to arnx: 3 real bugs, 13 minor defects, 26 intended behavior, 12 wrong tests, 11 unreachable.

## Compare
- [arnx vs Claude Code's native review](https://arnx.dev/compare/claude-code-review/): Claude Code's own review reads the change and reports findings in the same tool that wrote it. arnx is a separate tool that proves suspected bugs with tests it runs.
- [arnx vs CodeRabbit](https://arnx.dev/compare/coderabbit/): CodeRabbit reviews pull requests across a team in any language. arnx runs before the pull request and backs each finding with a test it executed. Many teams can use both.
- [arnx vs Greptile](https://arnx.dev/compare/greptile/): Greptile reviews every pull request with a graph of the whole codebase. arnx runs before the pull request and backs each finding with a unit-level test it executed.

## Optional
- [Full text for agents](https://arnx.dev/llms-full.txt): the pages above as one Markdown file.
- [Release documentation](https://github.com/arnx-dev/arnx#readme)
- [License](https://arnx.dev/license.html)
- [Privacy](https://arnx.dev/privacy)
- [Terms](https://arnx.dev/terms)
- [Cloud credits](https://arnx.dev/credits)
- [Contributing](https://arnx.dev/community.html)

This overview does not replace the pages, sitemap or robots.txt, and does not guarantee discovery by AI search.