BYO LLM code review.

Open source AI code review with the model you choose. Bring your own key and pay the provider at list price, with zero markup.

Start free See supported models

BYOK docs · Self-host Kodus

Trusted by 5,000+ teams around the world

What it is

BYO LLM code review is when the AI that reviews your pull requests runs on a model from your own provider account, with your own API key.

Kodus charges per seat for the product. Your provider bills you for inference at its list price, and nothing is added in between.

What you control when you bring your own model

You set this up once in Settings, on any plan. Self-hosted installs can also set it in .env.

The provider and the key

Pick one of 12 built-in providers or any OpenAI-compatible endpoint, including a model you run yourself. Keys are encrypted and never shown again after you save them.

Which model runs where

Set the model per repository, per directory and per task. Code review can run on one model while PR summaries run on a cheaper one. A change applies to the next review, with no redeploy.

What happens when a provider fails

Add a fallback model and Kodus retries once on it after a rate limit, a server error or a timeout. Cap concurrent requests to stay under your provider's limits.

What each review costs

The Token Usage page shows tokens and cost per review, per model and per task. A monthly spend limit alerts you at 50, 75, 90 and 100 percent.

One model per repo, directory or task

Set a default model, then override it where it makes sense. If a call fails, Kodus retries it once on your fallback model.

Repositoryacme/api claude-sonnet-5Anthropic API
Directoryacme/web/src/ui/ gemini-3.8-flashGemini API
TaskPR summaries glm-5.3GLM Coding Plan, flat monthly fee
Repositoryacme/data-platform Qwen3.8-27BvLLM inside your network
Fallbackany failed call gpt-6-solOpenAI API

Scopes: An organization default, then overrides per repository and per directory.
Tasks: Code review, Kody Rules review, rule generation, business rules validation, PR summaries and conversations in the PR.
Fallback: Retried once after a rate limit, a server error, a timeout or an invalid key.

Which LLMs work with Kodus

12 providers are built in, including coding plan subscriptions from Z.ai and Kimi, and any API that speaks the OpenAI format works through a custom base URL. In Kodus Cloud you add the key in Settings. Self-hosted installs can use the same screen or three variables in .env.

OpenAI Anthropic Google Gemini Google Vertex AI Amazon Bedrock Azure OpenAI OpenRouter Novita Moonshot / Kimi Z.ai / GLM OpenAI-compatible Anthropic-compatible GLM Coding Plan Kimi Code Plan OpenCode Go Synthetic + Groq, Together, Fireworks, vLLM, Ollama…

OpenAI

Anthropic

Gemini Local

# Self-hosted .env. Same 3 vars for every provider.
API_OPENAI_FORCE_BASE_URL="https://api.openai.com/v1"
API_OPEN_AI_API_KEY="sk-..."
API_LLM_PROVIDER_MODEL=gpt-6-sol

# Claude keys go in the same variable.
# Kodus calls Anthropic through its native SDK.
API_OPENAI_FORCE_BASE_URL="https://api.anthropic.com/v1"
API_OPEN_AI_API_KEY="sk-ant-..."
API_LLM_PROVIDER_MODEL=claude-sonnet-5

# Gemini through its OpenAI-compatible endpoint.
API_OPENAI_FORCE_BASE_URL="https://generativelanguage.googleapis.com/v1beta/openai"
API_OPEN_AI_API_KEY="..."
API_LLM_PROVIDER_MODEL=gemini-3.8-flash

# Point at a server you run:
# vLLM, Ollama, TGI, LiteLLM, any OpenAI-compatible API.
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

In Kodus Cloud you pick the same provider, key and model in Settings, no .env needed.

What you pay with your own LLM key

You get two separate bills: Kodus charges for seats, and your provider charges for the tokens your reviews use, at its list price.

Kodus bills you

Seats, per developer

Community, self-hosted: Free
Teams, billed annually: $8/dev/month
Teams, billed monthly: $10/dev/month
Enterprise: Custom

No limit on PRs or reviews on any plan. Pricing has the full plan details.

Your provider bills you

Tokens or a flat subscription

Pay-per-token API: Provider list price
Coding plan subscription: Flat monthly fee
Markup from Kodus: $0
Model running on your servers: Your compute only

For example, Claude Sonnet 5 lists at $2 per million input tokens and $10 per million output tokens (September 2026). The Token Usage page in Kodus shows what each review used.

AI code review tools that support bring-your-own LLM keys

Where each tool lets you use your own model, and on which plan. Checked against each vendor's docs and pricing pages in September 2026.

Capability		PR-Agent	Qodo	CodeRabbit	Greptile	Sourcery	GitHub Copilot
Bring your own LLM key	Every plan, Cloud and self-hosted	Yes, self-hosted only	Enterprise plan	Self-hosted Enterprise, 500+ seats	Self-hosted Enterprise	Enterprise plan	No, code review doesn't support model switching
Providers	12 built in, plus any OpenAI-compatible API	Any LiteLLM provider	OpenAI, Anthropic, Azure OpenAI, Bedrock, self-hosted models	OpenAI, Azure OpenAI, Bedrock	OpenAI-compatible APIs, Bedrock	Not documented	GitHub picks the models
Model running inside your network	vLLM, Ollama, TGI, LiteLLM	Ollama and others via LiteLLM	Self-hosted models, Enterprise	Not documented	Custom base URL	Not documented	No
Different model per repository	Per repository, directory and task	Per-repo config file	Not documented	Not documented	Not documented	Not documented	No
Open source	AGPLv3	MIT	No	No	No	No	No
Paid plan price	Teams: $8/dev/month annual, $10 monthly, plus your provider bill	Free, plus your provider bill	Pro Team: $30/month for up to 30 users, plus credits	Team: $48/dev/month annual, $60 monthly	Pro: $30/seat/month, plus credits	Team: $24/dev/month annual, $30 monthly	Included in paid Copilot plans, AI credits per review

Who brings their own model

Most teams that bring their own model to code review fall into one of these groups.

Existing AI contracts

Use the AI contract you already have

If your company already pays for Azure OpenAI, Bedrock or Vertex AI, reviews run on that contract, its credits and its data terms. No new AI vendor to approve.

Cost control

Spend on the model where it matters

Run code review on a strong model and PR summaries on a cheap one. The Token Usage page shows which repos and tasks drive the bill.

Open-weight models

Review with a model you host

Run Kimi, GLM, DeepSeek, Qwen or Llama on vLLM or Ollama. With self-hosted Kodus, code never leaves your network.

Model changes

Change models when you decide to

Set an exact model ID and it stays until you change it. When a better model ships, switch in Settings and the next review uses it.

FAQ

kodus-byo-llm-faq(1) bash

KODUS-FAQ(1) BYO LLM KODUS-FAQ(1)

BYO LLM (bring your own LLM) code review means the AI that reviews your pull requests calls a model on your own provider account, with your own API key. The review vendor charges for its product, and your provider bills you directly for inference.

As of September 2026, Kodus supports your own key on every plan, in the cloud and self-hosted. PR-Agent (MIT) supports it when you self-host it. Qodo and Sourcery offer it on their Enterprise plans, and CodeRabbit and Greptile only on self-hosted Enterprise deployments, with CodeRabbit requiring 500+ seats. GitHub Copilot code review does not let you choose the model.

No. Kodus charges per seat for the product. Your LLM provider bills you for inference at its own list price, and Kodus adds nothing on top.

Kodus has 12 built-in providers: OpenAI, Anthropic, Google Gemini, Google Vertex AI, Amazon Bedrock, Azure OpenAI, OpenRouter, Novita, Moonshot, Z.ai, plus generic OpenAI-compatible and Anthropic-compatible endpoints. Groq, Cerebras, Together AI, Fireworks and any other OpenAI-compatible API work through a custom base URL.

Yes. The GLM Coding Plan and the Kimi Code Plan are built-in options, and Kodus sets their concurrency limits for you. OpenCode Go and Synthetic work through their OpenAI-compatible endpoints. A subscription caps your monthly model spend. Because these plans limit concurrent requests, pair one with a pay-per-token fallback model for busy days.

Kodus suggests Claude Sonnet by default. The BYOK docs also recommend Gemini Pro, the latest GPT model, and the Kimi and GLM coding plans. You can start with one and switch later, since the change applies to the next review.

Yes. Point the base URL at an OpenAI-compatible server you run, such as vLLM, Ollama, TGI or LiteLLM, and set the model name. With self-hosted Kodus, the whole review can run without calling an outside provider.

Yes. Azure OpenAI, Amazon Bedrock and Google Vertex AI are built-in providers, so reviews can use the contract and credits your company already has. Vertex also works without a key through Application Default Credentials. Gateways like LiteLLM or OpenRouter work as an OpenAI-compatible endpoint.

Yes. You can set the model per repository and per directory. You can also route each task to its own model: code review, Kody Rules review, rule generation, business rules validation, PR summaries and conversations in the PR.

If you set a fallback model, Kodus retries the call once on it after a rate limit, a server error, a timeout or an invalid key. You can also cap concurrent requests per provider to stay under its limits.

The Token Usage page shows tokens and cost for each review, with a breakdown by model and by task. You can set a monthly spend limit that sends alerts at 50, 75, 90 and 100 percent. Your provider's own dashboard shows the same spend.

Yes, and on the free Community plan it is required: reviews run on your own key. The 14-day trial includes a default model paid by Kodus, so you can test before adding a key. Teams and Enterprise also support your own key.

No. Kodus sets no limit on the number of pull requests or reviews. The limits you run into are your provider's. Pull requests with more than 200 changed files are skipped.

Keys are encrypted in transit and at rest, and Kodus never shows them again or writes them to logs in plain text. On self-hosted Kodus, keys set in .env stay on your servers.

Both are open source and both let you bring your own key, pick the provider and run a local model. PR-Agent (MIT) is a self-hosted tool you configure through files and run from the CLI, a GitHub Action or a webhook. Kodus (AGPLv3) also has a hosted cloud, a web app for setup and review history, per-repository and per-task model routing, fallback models and a token usage page.

Bring your own model to Kodus

Add your provider key in Settings, or set three variables in .env if you self-host. The next review runs on your model.

Start free Read the BYOK docs

Star kodus-ai on GitHub