Open source, self-hosted AI code reviewers exist, but the field is smaller and messier than most listicles suggest. Several tools that get called "open source AI code reviewers" — including some cited in aggregator round-ups — are actually closed-source SaaS products with no self-hosted edition at all. This piece separates the projects you can genuinely git clone, point at your own GPU, and wire into your CI pipeline from the ones you can only rent.
The short answer
Three projects currently make up the realistic self-hosted shortlist:
- Qodo Merge (formerly PR-Agent) — an Apache-2.0 licensed pull-request reviewer that posts inline suggestions, auto-generates PR descriptions, and answers questions about a diff. It runs as a GitHub Action, GitLab/Bitbucket webhook, CLI tool, or Docker container, and it can point at a fully local model instead of a hosted API.
- Aider — a terminal-based AI pair-programming tool that is git-aware, diff-aware, and works against local models served by Ollama or an OpenAI-compatible endpoint. It isn't a dedicated PR-bot, but plenty of teams use it for pre-commit review and refactor passes on the same box that hosts their model.
- Continue — an open-source IDE extension for VS Code and JetBrains that surfaces AI review comments and chat directly in the editor, and can be pointed at a self-hosted model rather than a vendor API.
None of these require sending code to a third party if you don't want to. All three are free to inspect, fork, and modify, which is the actual definition of open source — a bar that a lot of marketing copy quietly skips past.
What "open source" doesn't mean here
Several well-known AI review products are commercial SaaS with no self-hosted, open-source edition. CodeRabbit is one of the most-cited examples: it offers a free tier and a paid Pro tier, but the review engine itself runs on CodeRabbit's infrastructure, not yours. Treat any roundup that describes a "Community Edition" or "OSS edition" of a SaaS-only product with skepticism, and check the vendor's own docs before planning a deployment around it.
Hardware sizing: what actually determines VRAM need
The determining factor for a self-hosted reviewer isn't the reviewer tool itself — PR-Agent, Aider, and Continue are all lightweight orchestration layers — it's the size of the local LLM you point them at. Ollama's own model library documentation lays out the rule of thumb most self-hosters end up following: a 7B-class model at common quantization levels fits comfortably in around 8GB of VRAM, a 13B-class model wants roughly 16GB, and 30B+-class models are realistically a 24GB-or-larger card. Coding-tuned models such as Qwen2.5-Coder, DeepSeek-Coder, and CodeLlama follow the same curve as their general-purpose counterparts at equivalent parameter counts.
For context on what that looks like with real GPUs already covered here: Qwen 3.8 on a 12GB RTX 3060 covers exactly this class of budget-card sizing, and the Qwen 3.8 vs Kimi K3 comparison is a useful reference if you're deciding between a smaller always-fits model and a larger one that needs more headroom. If you're leaning toward genuinely large local models, Kimi K3's open-weights hardware requirements is the more realistic planning document — it's not a run-this-on-a-laptop model.
NVIDIA vs. AMD for this workload
CUDA has the deepest, most mature support across the inference runtimes these tools lean on — llama.cpp, vLLM, and Ollama's own backend — so an NVIDIA card remains the path of least resistance if you want the shortest setup time and the widest model-format compatibility. AMD's ROCm stack has closed a lot of that gap for the same runtimes, and coverage of local security-focused LLM inference on an RTX 3060 is a useful case study for what local inference on a mid-range card looks like in practice, even though that piece covers a different model family. If you already own an AMD card, it's worth testing before buying new hardware — but budget extra setup time versus the CUDA path.
Step-by-step: self-hosting Qodo Merge with a local model
- Install a local inference server. Ollama is the simplest on-ramp — it handles model downloads and quantization, and exposes an OpenAI-compatible API on
localhost:11434. - Pull a coding-tuned model sized to your VRAM (see the sizing section above) — a coder-class model in the 7B–14B range is the practical starting point for most single-GPU homelabs.
- Point Qodo Merge at the local endpoint instead of a hosted API key, using its local model provider configuration — this is the step that actually makes the deployment self-hosted end-to-end, rather than "open-source client, closed-source brain."
- Deploy the trigger. For GitHub, that's the official Qodo Merge Action in your workflow file; for GitLab or Bitbucket, it's the webhook integration documented in the project's repo.
- Test on a real PR before relying on it — confirm the review comments land, the model isn't timing out on large diffs, and the container has enough VRAM headroom left for your normal dev workload if it shares a GPU with anything else.
None of this requires exotic hardware. It requires a GPU with enough VRAM for the model you choose, Docker, and some patience for the first setup pass.
Security and cost: the actual tradeoffs
The honest case for self-hosting isn't a specific dollar figure — that depends entirely on team size, existing GPU capacity, and which SaaS tier you'd otherwise be comparing against — it's two structural differences:
- Code never leaves your network. For teams under NDA, government contracts, or working on unreleased hardware or proprietary algorithms, that's often the deciding factor over any per-seat pricing comparison.
- No vendor lock-in or per-seat billing, in exchange for taking on the operational burden yourself: GPU maintenance, model updates, and keeping the reviewer's output quality current as new coder models ship.
That second point is the one aggregator content tends to gloss over. A self-hosted reviewer is a real piece of infrastructure you now own, not a subscription you cancel if it's not working out. Teams that already have GPU capacity — from a homelab, an on-prem inference server, or spare capacity on an AI rig they already run for coding-assistant comparisons — get the best return on this tradeoff, since the marginal cost of adding a reviewer workload is close to zero.
If you're already running other self-hosted services on the same box — media servers, home automation, or something like Jellyfin on modest hardware — the code reviewer is a natural addition to that same homelab rather than a reason to buy new hardware from scratch.
FAQs
Is CodeRabbit open source? No. CodeRabbit is a commercial SaaS product with a free tier and paid plans; there is no self-hosted, open-source edition of its review engine, despite some aggregator content implying otherwise.
Do I need a GPU to self-host an AI code reviewer? Not strictly — Ollama and similar runtimes can run small models on CPU — but latency on anything beyond a tiny model gets impractical for interactive PR review. A GPU with enough VRAM for your chosen model is the realistic baseline.
Which is easier to set up, Qodo Merge, Aider, or Continue? Qodo Merge is the most turnkey for automated PR review specifically, since it ships GitHub, GitLab, and Bitbucket integrations out of the box. Aider and Continue are closer to interactive assistants and take more configuration to slot into an automated review pipeline.
NVIDIA or AMD for running the local model? NVIDIA and CUDA have the broadest, most mature support across llama.cpp, vLLM, and Ollama, making it the lower-friction choice. AMD's ROCm support has improved significantly and is workable if you already own the hardware.
Can I use these tools on GitLab or Bitbucket, not just GitHub? Yes — Qodo Merge supports GitHub, GitLab, and Bitbucket. Aider and Continue are host-agnostic since they operate on your local git checkout rather than through a platform-specific webhook.
How much VRAM do I actually need? As a rule of thumb from Ollama's own model documentation: roughly 8GB for a 7B-class model, 16GB for 13B-class, and 24GB or more for 30B+-class models, all at common quantization levels.
Citations and sources
- https://github.com/qodo-ai/pr-agent
- https://aider.chat
- https://continue.dev
- https://ollama.com
- https://coderabbit.ai
This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.