Decide where the code may go#
A private repository on GitHub.com already sits with GitHub. Adding an AI reviewer sends its diffs and surrounding files to at least two more places: the service that reads the pull request and builds the prompt, and the model endpoint that answers it. A team that needs to control where source code goes has to answer for each place separately.
Two shortcuts give the wrong answer. Choosing your own model provider changes who receives and bills the prompts; a hosted reviewer still reads the code on the vendor's machines before it calls that provider. A free plan for public or open-source repositories is a price for a hosted service; it gives you no software to run. An open-source license does give you that right, but only for the code it covers, and you still choose where that code runs.
Separate the deployment into four parts before comparing products:
| Part | The question it answers | What to check |
|---|---|---|
| Reviewer hosting | Which machine fetches the pull request, assembles context and posts comments? | Whether the project documents running it on your own machines, and which of its components need a public address |
| Model hosting | Which endpoint receives prompts that contain your code? | Whether the reviewer accepts a custom endpoint, and whether the model server sends any requests elsewhere |
| Credentials | Who holds the tokens that read the repository, write comments and call the model? | Token permissions, where secrets are stored, and whether any optional service needs its own key |
| Operating cost | What keeps it running after the trial? | Machines, model capacity, upgrades, monitoring and the engineer who answers when a review fails |
Options to evaluate#
The licenses and installation documents below were checked on 20 November 2026. Proofline publishes this guide; it is a hosted service with no self-hosted installation. The table names the part each project lets you run and is not a quality ranking.
| Project | License | What you can run | Model it calls | Credentials you manage |
|---|---|---|---|---|
| PR-Agent | MIT | The reviewer, as a GitHub Action or a self-hosted GitHub App | Commercial APIs or your own server through LiteLLM, including Ollama and OpenAI-compatible endpoints | Workflow token or GitHub App key and webhook secret, plus a model key when the endpoint needs one |
| Kodus Community | AGPL-3.0, with Enterprise Code under its own license | The reviewer's API, worker, webhook service and web app, with their databases and queue | Any OpenAI-compatible endpoint you configure, including one you host | Git provider credentials, database and queue passwords, model key and any optional service keys |
| Ollama | MIT | A model server on your hardware | Local models, unless you also use its cloud models | Your network access controls |
| vLLM | Apache-2.0 | An OpenAI-compatible model server on your GPUs or CPUs | The open-weight models you load | An API key option and your network access controls |
Ollama and vLLM are model servers, not reviewers. Pair one with a reviewer that accepts its endpoint. Open-weight models carry their own licenses, separate from the server's license, so read the model's license before you load it.
PR-Agent: a reviewer you can run inside a workflow#
PR-Agent's GitHub installation guide documents two ways to run the reviewer. As a GitHub Action, a workflow file runs PR-Agent's container on each pull request with the workflow's GITHUB_TOKEN and a model key. As a GitHub App, you create the App, hold its private key and webhook secret, build the Docker image and host the webhook server yourself. Qodo donated PR-Agent to its community; the project now lives in the PR-Agent organization on GitHub and is maintained there, apart from Qodo's hosted reviewer.
Its model guide shows how to point PR-Agent at Ollama or at an OpenAI-compatible server such as vLLM. Two notes in its guides affect a private deployment. The installation guide says Ollama must be reachable from the Action's container, where localhost means the container itself. The model guide states that, in its maintainers' testing, "local open-source models are suitable for experimentation and learning purposes (mainly for the ask command), but they are not suitable for production-level code analysis tasks." The note describes open-source models available as of January 2025. Test the models you can host on your own pull requests before you depend on them.
Kodus: a self-hosted review service with a dashboard#
Kodus's installation guide runs the service with Docker on a virtual machine. Its README asks for at least 2 CPU cores, 8 GB of RAM and 60 GB of free disk. The installation configures PostgreSQL, MongoDB and RabbitMQ, a public hostname for the web app and a webhook URL that your Git provider can reach. You set the model with API_LLM_PROVIDER_MODEL, API_OPENAI_FORCE_BASE_URL and API_OPEN_AI_API_KEY, so the endpoint can be a model server you operate.
Read the optional settings as data flows. The guide lists E2B, which runs and validates code during reviews, and MorphLLM, which applies suggestions, as optional services that improve reviews. Each is an external account, and enabling it sends review material to that service. A self-hosted instance also sends one anonymous heartbeat a day with aggregated counters and no code; KODUS_TELEMETRY_DISABLED=true turns it off. Kodus also sells a hosted cloud, so choosing Kodus does not by itself mean self-hosting. The free Community edition limits custom review rules to 10 and active plugins to 3. Its Enterprise Code license lets Community users run the unmodified enterprise files that Community features need, within limits the software enforces, but not change them.
Ollama and vLLM: hosting the model#
Ollama's FAQ says it binds to 127.0.0.1 port 11434 by default and documents how to expose it on a network. It also runs cloud models: in Ollama's words, "Inference runs on Ollama's cloud service." Set OLLAMA_NO_CLOUD=1, or disable_ollama_cloud in its server configuration, to keep inference on your hardware. PR-Agent's model guide adds that Ollama's context window can be too small for review prompts: set OLLAMA_CONTEXT_LENGTH and match it with the reviewer's custom_model_max_tokens.
vLLM's installation guide covers NVIDIA, AMD and Intel GPUs and several CPU platforms. Its OpenAI-compatible server accepts an --api-key, but the documentation warns that the key protects only some endpoints and recommends hardening such as a reverse proxy. Keep the server on a private network that only the reviewer can reach.
A worked decision for one private repository#
Consider a hypothetical team with a private repository on GitHub.com and three requirements: code may leave GitHub only for machines the team operates, no third-party model API may receive it, and no service in the team's network may accept connections from the internet.
The team runs PR-Agent as a GitHub Action on a self-hosted runner inside its network and points it at vLLM on a GPU host that only the runner can reach. Each requirement maps to one part of this setup:
| Requirement | How the setup meets it |
|---|---|
| Code reaches only machines the team operates | The runner fetches the pull request and builds the prompt; the model server receives it. Both are the team's machines. |
| No third-party model API | The workflow sets only the private vLLM endpoint and no commercial model key. |
| No inbound connections from the internet | GitHub's runner reference requires the host to make outbound HTTPS connections; the setup needs no public webhook. |
| Narrow GitHub credentials | The workflow's GITHUB_TOKEN carries the permissions the workflow file grants: read contents, write issues and pull request comments. |
Kodus fails the third requirement as installed, because GitHub.com must deliver webhooks to its URL. A team that can publish one endpoint and wants a review dashboard can choose it instead.
The unsuitable option looks almost identical. The same MIT-licensed PR-Agent workflow with runs-on: ubuntu-latest and an OPENAI_KEY secret runs on a GitHub-hosted runner and sends each diff to the model provider. That is a reasonable choice for a team that accepts a commercial provider, and it fails this team's requirements even though the reviewer is open source and configured in their own repository. A hosted reviewer used with the team's own model key fails for the same reason.
Count the cost of running it yourself#
GitHub's documentation says self-hosted runners are free to use with Actions and that you pay for maintaining the machines. Self-hosting moves spending from a subscription to infrastructure and engineering time:
| Cost | What to estimate |
|---|---|
| Reviewer machines | A runner or a virtual machine for the service, with its databases, backups and upgrades |
| Model capacity | GPU memory for the model and context length you choose, sized for reviews that arrive together |
| Maintenance | Updating the reviewer, model server and models, and reading their release notes before each upgrade |
| Review time | Developer time spent judging findings, which a weaker local model can increase |
Run the trial with the model you can afford to host, because a reviewer tested against a larger commercial model may perform differently on your own hardware.
When budget is the only constraint#
If a free reviewer is the goal and your code may go to a hosted service, self-hosting adds work you do not need. Compare free AI code review offers for ongoing free plans, trials and their entry terms. For a broader shortlist, the AI code review tools guide compares hosted reviewers by context, controls and cost.
Where Proofline fits#
Proofline is a hosted reviewer for GitHub pull requests. With BYOK code review, you choose the model provider and pay it directly, but the review still runs on Proofline's service. It does not meet the requirements in the worked decision above. For a team that accepts a hosted reviewer, new organizations can try one calendar month of hosted code review without a card, model key or cloud connection, subject to eligibility and fair use.
Questions#
Can AI code review run entirely on our own hardware?
Yes, when both the reviewer and the model server run on your machines, such as PR-Agent on a self-hosted runner with Ollama or vLLM. Your Git host still holds the repository. Compare findings from the models you can host before relying on them: PR-Agent's maintainers found local models weaker than commercial ones for production review in their testing.
Does bringing our own model key make a reviewer self-hosted?
No. Your own key decides which provider receives and bills the prompts. A hosted reviewer still reads your code on its vendor's machines before calling that provider.
Is an open-source license enough for a private repository?
A license lets you run and change the covered code. Check which parts it covers, where the documented installation runs and which optional services it calls. The same open-source reviewer can send code to a third party or keep it on your machines, depending on how you deploy it.