Compare / Greptile

arnx and Greptile look at a change from two sides.

One reads the whole codebase. One runs tests on the change.

Greptile is a hosted AI reviewer that comments on every pull request, using a graph of the whole repository to reason beyond the diff. It works with any language and the common code hosts. arnx is an open-source CLI that a developer or their coding agent runs on their own machine once a change is finished. It writes tests for what looks broken, runs them in Docker, reruns each failure on the code before the change, and reports the tests that failed.

They answer different questions. Greptile asks what a reviewer who knows the codebase would say about this pull request. arnx asks which suspected bugs it can reproduce with a test. A team can use Greptile at the pull request and arnx before it.

Side by side

arnx 0.1.11 and Greptile, from each product's own documentation on 2026-11-12
	arnx	Greptile
Where review happens	On the developer's machine, after a change is finished and before the commit or pull request. Run by the developer or by their coding agent.	Pull requests: it automatically reviews every pull request. A CLI can review local branches before you push; It ignores uncommitted changes.
Installation	`npm install -g @arnx-dev/arnx` or a standalone binary, then `arnx init`. Needs Docker. No code-host app.	Install its GitHub App, or connect GitLab with an access token and webhook, then enable repositories (code providers). CLI: `npm install -g greptile@latest`, then `greptile login`.
Output	A local report, `review.md`, where each finding is a test file you can run, with its failure output. arnx posts no pull request comments.	Pull request comments with suggested fixes. Per its key features, every comment has a Fix with your Agent button that sends the issue to a coding agent.
Test generation and execution	Always. It writes tests for what looks broken and runs each one 3 times in a local Docker sandbox with no network.	On request: its docs give the example @greptileai can you create a test for this file?. An opt-in feature labelled beta, TREX, Starts your app in a sandbox built from your environment, uses it like a user would, and posts what broke with a video. We did not find in their documentation that a base review runs unit tests.
Before and after comparison by running code	Yes. Each failing test is rerun on the code before the change. The report says whether it is a regression, was already failing, or covers new code.	We did not find this in their documentation.
Developer triage	`arnx triage`: mark each issue real, intended, noise or rewrite, and answer arnx's questions. A second model confirms or disputes each finding first.	Reactions on comments: Only 👍 and 👎 train the system. Rules can also be set in the dashboard or in repository config.
Keeping regression tests	`arnx accept` keeps the tests of real issues in `.arnx/tests/`, pinned by sha256. `arnx check` reruns them with no model calls.	TREX custom flows are app journeys kept in the Greptile dashboard: TREX runs it as written whenever a pull request touches it. We did not find in their documentation a way to keep generated code tests as pinned checks.
Languages and platforms	Python (pytest), JavaScript and TypeScript (vitest, jest, node:test, bun), Rust (cargo-nextest, early). macOS and Linux; Windows through WSL 2. Any Git repository, no code host needed.	Greptile works with any programming language. GitHub, GitLab, Bitbucket and others, including Gitea and Perforce.
Where code is processed	Tests and tool calls run locally. The diff, the files the reviewer reads, the tests and their output go to your own model providers, or to arnx Cloud if you choose it.	Hosted: Greptile Cloud is hosted on Amazon Web Services, with zero data retention agreements with LLM providers. A licensed self-hosted option exists.
Cost model	Open source (Apache-2.0) with your own model keys: you pay providers per review, capped by `review_usd` ($3.00 by default). Our own reviews ranged from $0.17 to $3.19. Or prepaid arnx Cloud credit.	Prepaid credits, no seats. From its billing page: Credits cost $1 each and are shared across your organization. A Base review is 1 credit, Plus 3, Apex 10, and a TREX run 3. CLI reviews cost the same and The free plan doesn't include them.

Both products can execute something. Greptile's TREX drives a running app like a user and records video. arnx runs unit-level tests it wrote for the change and compares them with the code before it. arnx runs no browser tests.

When Greptile is the better choice

You want every pull request reviewed for a whole team without anyone running a command.
The risk is in how a change ripples through a large codebase. Its key features page says it builds a graph of your repository to reason about effects beyond the diff, including across repositories.
Your code is not Python, JavaScript, TypeScript or Rust, or lives on a host such as Bitbucket, Gitea or Perforce.
You want a web app exercised end to end in a sandbox, with video. That is TREX, and arnx has nothing like it.
You need a self-hosted or air-gapped deployment of the reviewer itself, which its documentation describes under a license.
You do not want to run Docker or manage model keys.

When arnx is the better choice

You want a finding you can run: a test, its failure, and whether it passed before the change.
You want to check uncommitted work or a coding agent's change before a pull request exists. The arnx skill lets the agent run the review and fix the code against the accepted tests.
You want to keep the tests in your repository. Accepted tests are pinned and rerun by arnx check with no model calls.
You want open source (Apache-2.0), your own model keys, prompts you can edit, and tests that run only on your machine.

Using both

Run arnx on your machine when the change is done: triage the findings, fix what is real, and commit the accepted tests with the fix. Then open the pull request and let Greptile review it with the rest of the codebase in view. arnx does not replace a pull request reviewer, and it posts nothing there. One example of arnx on a repository that already used an automated pull request reviewer is the Hummingbot case study.

What arnx does not do

Three languages only: Python, JavaScript and TypeScript, and Rust (early). It works best on single-package Python and TypeScript repositories.
It needs Docker and a project with an existing test suite. Code in no such project is reported as not reviewed. Tests that run only in a browser are not run.
A review takes minutes, not seconds, and the first one also sets up the test environment (it stops at 10 minutes). Changes over 200 KB are refused; review a long branch in parts.
It posts nothing to a pull request. The report is a local file.
Findings can be wrong. A failing generated test shows an assertion fails, not that the code is wrong, and the second model can agree with a wrong test. Our own counts are in AI code review findings on unfamiliar repositories. Deciding stays with the developer.

Sources

Last reviewed 2026-11-12. Every statement about the other product comes from its own pages below, as they read that day. Products and prices change: check the vendor's pages before you decide. Found an error? Open an issue and we will correct it.

Last reviewed 2026-11-12 against arnx 0.1.11. The release documentation is canonical for your installed version.