Self-hosted AI code review.
Open source AI code review without vendor lock-in. The full review pipeline runs on your infrastructure, your database, your network. Bring any LLM, pin any version, keep every audit trail on your side of the network.
Self-hosted AI code review is when the AI that reviews your pull requests runs on your own infrastructure, not on a vendor's cloud. Source code, LLM calls, and review history stay inside the network your team controls.
What stays inside, stays inside.
SaaS code review forces every diff to leave your network. Self-hosting Kodus draws the line where your audit boundary already lives. Four guarantees come with the deploy.
01 ━
Source code never leaves your VPC
Webhooks land on your domain. Diffs read from your Git host. Embeddings persist in your Postgres. The pipeline is local end to end.
02 ━
You pick where the LLM call goes
Route to a hosted provider you already trust, or to an internal OpenAI-compatible endpoint. Kodus does not relay LLM traffic through anything you don't control.
03 ━
Audit trails live in your stack
Every API call, every worker job, every webhook is a log line in your existing aggregator. Retention, redaction, and access stay under your policy.
04 ━
Fork it, audit it, run it
The agent is AGPLv3. The Docker images are pinned and reproducible. Updates ship as tagged releases. No kill switch we control.
From PR opened to inline comments. Four stages, your network.
Deterministic pipeline. Real components in the repo, no marketing-ware. Click any stage to read the source.
Trigger from your Git host or the CLI.
Webhooks come in from GitHub, GitLab, Bitbucket, and Azure DevOps. Self-managed flavors work the same way: GitHub Enterprise Server, GitLab Self-Managed, Bitbucket Data Center. Or skip the Git host entirely and trigger reviews from the Kodus CLI in your dev loop or CI.
Kody builds the picture before it writes anything.
A sandbox is provisioned for the review (local on your box, hosted on E2B, or skipped entirely if you don't want one). Kody reads the diff, walks the code structure, and pulls in your Kody Rules and linked tickets. Everything assembled, then it starts looking for problems.
One reviewer by default. Four specialists when you ask for it.
In normal mode Kody runs as a single generalist reviewer that covers logic, security, and performance in one pass, plus your Kody Rules agent if you have rules configured. Switch the review to deep mode and three dedicated specialists go in parallel instead. Same model you brought, same sandbox.
default · logic, security, and performance in one agent
enforces your team's custom rules and conventions
deep mode · three specialists run in parallel
every agent uses the provider you set in .env
Findings come back on the PR or in the CLI.
When the review starts on a PR, Kody posts line-anchored inline comments and sets approve or request-changes status, right next to the rest of your CI. When it starts from the CLI, the same findings stream back to your terminal as structured output you can pipe, fail builds on, or feed into another tool.
Off the public wire.
For defense contractors, sovereign environments, and IP-controlled networks. There is no packaged air-gap installer, but every dependency is replaceable with something you operate. Four switches and you are off the public internet.
Mirror the container images
Push ghcr.io/kodustech/* to your private registry. Pin KODUS_VERSION in .env so deploys stay reproducible offline.
Bring the LLM inside the wire
Point API_OPENAI_FORCE_BASE_URL at an internal OpenAI-compatible endpoint (vLLM, TGI, Ollama, or any inference server you operate on your network).
Use a local Git provider
Webhooks land where the diff lives. GitHub Enterprise Server, GitLab Self-Managed, or Bitbucket DC on the same network keep the loop closed.
Silence the heartbeat
Set KODUS_TELEMETRY_DISABLED=true. The anonymous daily ping is the only outbound call by default and it goes away with one flag.
Any provider you already trust.
The agent runs on the model you choose. Set it once in .env and pin it. Self-hosted means your contract, your spend, your data path.
# Same 3 vars for every provider. # Swap the base URL, swap the model, you are done. API_OPENAI_FORCE_BASE_URL="https://api.openai.com/v1" API_OPEN_AI_API_KEY="sk-..." API_LLM_PROVIDER_MODEL=gpt-5.1
# Anthropic exposes an OpenAI-compatible endpoint. API_OPENAI_FORCE_BASE_URL="https://api.anthropic.com/v1" API_OPEN_AI_API_KEY="sk-ant-..." API_LLM_PROVIDER_MODEL=claude-sonnet-4-6
# Gemini exposes an OpenAI-compatible endpoint. API_OPENAI_FORCE_BASE_URL="https://generativelanguage.googleapis.com/v1beta/openai" API_OPEN_AI_API_KEY="..." API_LLM_PROVIDER_MODEL=gemini-2.5-pro
# Same 3 vars. Point at your own gateway. # vLLM, Ollama, LiteLLM, TGI, any OpenAI-compatible server. API_OPENAI_FORCE_BASE_URL="http://llm.internal.your-co/v1" API_OPEN_AI_API_KEY="sk-local-anything" API_LLM_PROVIDER_MODEL=your-local-model
One config shape. The base URL is the switch. Kody never knows which vendor is on the other end.
Kodus self-hosted checks every box.
How Kodus stacks against the tools most often evaluated for code review when the audit boundary matters.
Only tool that ships all 8 properties at once.
| Capability |
Kodus
|
CR CodeRabbit | SK Snyk | SQ SonarQube | DS DeepSource |
|---|---|---|---|---|---|
| Deployment & Licensing | |||||
| Self-hosted | AGPLv3 | Cloud only | Agent | Yes | Hybrid |
| Open source | AGPLv3 | No | No | CE only | No |
| AI & Models | |||||
| AI-driven review | Yes | Yes | DeepCode | Static | Limited |
| Bring your own LLM | Any provider | Bundled | Snyk only | Bundled | |
| Compliance & Cost | |||||
| Audit boundary | Your VPC | Their VPC | Mixed | Your VPC | Their VPC |
| Air-gapped feasible | Yes | No | No | No AI | No |
| GDPR / LGPD residency | Your region | Off-region | Off-region | Your region | Off-region |
| Markup on LLM costs | Zero | Bundled | Bundled | Bundled | |
For teams where the perimeter is the point.
Regulated industries, IP-heavy R&D, and sovereignty-conscious teams use Kodus self-hosted to keep AI code review inside the existing audit perimeter.
Financial services
Cardholder data stays in scope.
Self-host Kodus inside the same network segment that already passed your PCI-DSS audit. No new third-party processor to add to the report.
Healthcare
PHI never crosses a BAA you don't own.
Reviews run inside your HIPAA-covered infrastructure. No business associate agreement to renegotiate with a code review vendor.
Regulated SaaS
GDPR & LGPD residency, no extra processors.
Pin Kodus to the region your data lives in. Keep your sub-processor list short and your DPA stack shorter.
High-IP engineering
Pre-release code stays inside the perimeter.
Proprietary algorithms and unreleased features are reviewed where they already live. Route the LLM call to a model you operate for an air-tight loop.
The controls security asks for.
Community ships with the basics every self-hosted team needs. Enterprise unlocks the controls a security review wants to see. Both run on the same Docker stack. See the security docs and the telemetry policy for the full picture.
OK sso-saml Enterprise ▶
firstName, lastName, email. Test the IdP connection before flipping the org-wide flag.
OK rbac Enterprise ▶
@CheckPolicies. Per-role scoping for repos, rules, and analytics. Roles are first-class and live in your database.
OK audit-logs Enterprise ▶
OK source-available-agent All editions ▶
OK secrets-in-your-vault All editions ▶
FAQ
Yes. The web UI, API, worker, webhooks, RabbitMQ, Postgres (pgvector), and MongoDB all run on your Docker host via the kodus-installer repo. The agent is AGPLv3. There is no required call-home to operate the product. It is open source AI code review without vendor lock-in.
Docker (latest stable) with the Compose plugin, a public-ish domain or fixed IP for Git provider webhooks, and a host with at least 8 GB of RAM. For repos beyond 100k lines of code, plan for 16 GB and give the worker container 4 to 8 GB on top. Default ports: 3000 (web), 3001 (api), 3332 (webhooks), 5432 (postgres), 27017 (mongodb), and 5672 / 15672 / 15692 (rabbitmq).
OpenAI, Anthropic, Google Gemini, Google Vertex AI, Novita, Groq, Cerebras, Together AI, Fireworks, Chutes, Moonshot / Kimi, Synthetic, and Z.ai / GLM are wired in the code. Anything else with an OpenAI-compatible API works through API_OPENAI_FORCE_BASE_URL, including an internal vLLM, TGI, or Ollama instance you operate.
Functionally yes, with caveats. Mirror the Docker images to a private registry, point Kodus at an internal OpenAI-compatible LLM endpoint, and set KODUS_TELEMETRY_DISABLED=true. The product itself does not need outbound traffic to operate. We do not ship a packaged air-gap installer today, so plan that operational glue yourself.
Community is the AGPLv3 codebase. Free, open source, self-host or hosted by us. Enterprise adds SSO, RBAC, audit logs, and analytics under a commercial license, activated with KODUS_LICENSE_KEY. Files marked .ee. in the repo are the EE add-ons.
Tagged releases on GitHub plus pinned Docker images via KODUS_VERSION. You promote the tag through your change-management process. Security advisories are published on the repo with CVE references. No auto-update channel.
An anonymous daily heartbeat: aggregated counters like PRs reviewed, integrations enabled, uptime, and node version. Never your source code, never PR titles, never identifiers, never your LLM traffic. Inspect with yarn telemetry:preview. Disable entirely with KODUS_TELEMETRY_DISABLED=true.
The production install is the kodus-installer repo: clone, fill in .env, run ./scripts/install.sh. The script generates secrets, creates the Docker networks, pulls the ghcr.io/kodustech/* images, and waits on healthchecks. Budget 15 to 30 minutes end to end for the first deployment, minutes for the ones that come after.
Yes. Kodus integrates with GitHub Enterprise Server, GitLab Self-Managed, and Bitbucket Data Center as first-class targets, alongside their cloud equivalents and Azure DevOps. Self-managed flavors use the same webhook signing and OAuth flows. Point Kodus at your internal Git host and the review loop closes inside your network.
CodeRabbit is cloud-only with a bundled LLM. Kodus self-hosts under AGPLv3, lets you bring your own LLM, and keeps source code, LLM calls, and audit logs on your infrastructure. Both review pull requests with AI. The choice is data sovereignty and cost control versus managed convenience. For the full comparison across deployment, models, and compliance, see the table above on this page.
Pull the repo. Run the review.
One docker compose away from an AI code reviewer that lives inside your perimeter.
/api/cockpit?orgId=…leaks cross-tenant rows.