FAQ — LiveReview
Most AI reviewers leave comments and stop there. LiveReview scores every pull request for risk and approves the safe ones, so your team only reviews what is risky. The approach follows Meta’s RADAR research, which reported 50× fewer production incidents, 3× fewer rollbacks and 35% faster reviews.
LiveReview runs on GitHub, GitLab, Bitbucket, Gitea and Azure DevOps, and every review, approval and override is recorded, so after an incident you can trace what was reviewed and why it shipped.
| LiveReview | CodeRabbit | |
|---|---|---|
| Review sources | Pre-commit review (git-lrc), every pull request, a PR link on the web, Slack, Teams and Discord, and AI agents via MCP | Pull requests, plus local reviews in its IDE extension and CLI |
| Approves safe pull requests | Yes. Approves the lowest-risk 30–50% of pull requests under your policy; risky or uncertain ones go to a human | Optional, off by default: approves once threads are resolved, pre-merge checks pass and the change is under a configured merge-risk and security-risk level |
| How risk is decided | Blends semantic LLM analysis, a custom ML model trained on your production risk signals, and static graph-based codebase analysis | Merge-risk and security-risk levels (minimal to critical); how they are computed is not documented |
| Learns from your production incidents and reverts | Yes. Every revert or incident you record retrains your organization’s own model | Not documented |
| Blast radius of each change | Yes. A graph of your whole codebase scores how far each change reaches (blast radius) | Not documented |
| Try a policy on past pull requests first | Yes. Replay a draft policy on your recent pull requests before turning it on | Not documented |
| Shows its impact in numbers | Yes. Pull requests approved without a human, what was blocked at each stage, and the false-approve rate (approved changes later reverted or tied to an incident) | Not documented |
| Pricing | Free 30k reviewed LOC a month; paid from $32 for 100k LOC with unlimited users. Cost follows reviewed code, not headcount | Per seat, so cost grows with the team even when the workload doesn’t |
| Usage limits | One limit: monthly reviewed LOC, across unlimited users and repositories | Hourly rate limits per developer per repository |
| Source code | Whole codebase source-available, with published security scan reports; self-host with one command | Closed source |
LiveReview runs on GitHub, GitLab, Bitbucket, Gitea and Azure DevOps, and every review, approval and override is recorded, so after an incident you can trace what was reviewed and why it shipped.
Most AI reviewers leave comments and stop there. LiveReview scores every pull request for risk and approves the safe ones, so your team only reviews what is risky. The approach follows Meta’s RADAR research, which reported 50× fewer production incidents, 3× fewer rollbacks and 35% faster reviews.
Teams on GitLab, Gitea, Bitbucket or Azure DevOps would need a separate product with Copilot; LiveReview covers all five through one git-level integration.
| LiveReview | GitHub Copilot review | |
|---|---|---|
| Review sources | Pre-commit review (git-lrc), every pull request, a PR link on the web, Slack, Teams and Discord, and AI agents via MCP | GitHub pull requests and the IDE |
| Approves safe pull requests | Yes. Approves the lowest-risk 30–50% of pull requests under your policy; risky or uncertain ones go to a human | Public preview, off by default: admins can let Copilot’s approval count toward required reviews, limited by file path |
| How risk is decided | Blends semantic LLM analysis, a custom ML model trained on your production risk signals, and static graph-based codebase analysis | An approval assessment on each review; the criteria are not documented |
| Learns from your production incidents and reverts | Yes. Every revert or incident you record retrains your organization’s own model | Not documented |
| Blast radius of each change | Yes. A graph of your whole codebase scores how far each change reaches (blast radius) | Not documented |
| Try a policy on past pull requests first | Yes. Replay a draft policy on your recent pull requests before turning it on | Not documented |
| Shows its impact in numbers | Yes. Pull requests approved without a human, what was blocked at each stage, and the false-approve rate (approved changes later reverted or tied to an incident) | Not documented |
| Git providers | GitHub, GitLab, Bitbucket, Gitea and Azure DevOps | GitHub only |
| Pricing | Free 30k reviewed LOC a month; paid from $32 for 100k LOC with unlimited users | Per user; each review uses a premium request from a monthly quota |
| Source code | Whole codebase source-available, with published security scan reports; self-host with one command | Closed source |
Teams on GitLab, Gitea, Bitbucket or Azure DevOps would need a separate product with Copilot; LiveReview covers all five through one git-level integration.
Most AI reviewers leave comments and stop there. LiveReview scores every pull request for risk and approves the safe ones, so your team only reviews what is risky. The approach follows Meta’s RADAR research, which reported 50× fewer production incidents, 3× fewer rollbacks and 35% faster reviews.
SonarQube and LiveReview work well together: keep your Sonar rules as a deterministic gate, and let LiveReview decide which changes are safe to ship without a human.
| LiveReview | SonarQube | |
|---|---|---|
| Review sources | Pre-commit review (git-lrc), every pull request, a PR link on the web, Slack, Teams and Discord, and AI agents via MCP | CI scans of branches and pull requests, and SonarQube for IDE |
| Approves safe pull requests | Yes. Approves the lowest-risk 30–50% of pull requests under your policy; risky or uncertain ones go to a human | No. A quality gate passes or fails a check; a human still approves |
| How risk is decided | Blends semantic LLM analysis, a custom ML model trained on your production risk signals, and static graph-based codebase analysis | Fixed static-analysis rules |
| Understands what the change means | Yes, semantic LLM review of every change | Rule matches only; AI CodeFix suggests fixes for issues the rules found |
| Learns from your production incidents and reverts | Yes. Every revert or incident you record retrains your organization’s own model | No, rules don’t learn from outcomes |
| Blast radius of each change | Yes. A graph of your whole codebase scores how far each change reaches (blast radius) | Not documented |
| Your own deterministic rules | Yes, per organization and per repository | Yes, quality profiles and gates |
| Shows its impact in numbers | Yes. Pull requests approved without a human, what was blocked at each stage, and the false-approve rate (approved changes later reverted or tied to an incident) | Code-quality metrics, not production outcomes |
| Source code | Whole codebase source-available | Community Edition is source-available with limited features; Developer and Enterprise editions are closed |
| Self-hosting | One command, under 5 minutes | A resource-heavy server to set up and maintain |
SonarQube and LiveReview work well together: keep your Sonar rules as a deterministic gate, and let LiveReview decide which changes are safe to ship without a human.
Most AI reviewers leave comments and stop there. LiveReview scores every pull request for risk and approves the safe ones, so your team only reviews what is risky. The approach follows Meta’s RADAR research, which reported 50× fewer production incidents, 3× fewer rollbacks and 35% faster reviews.
| LiveReview | Claude Code / Claude Code Review | |
|---|---|---|
| Review sources | Pre-commit review (git-lrc), every pull request, a PR link on the web, Slack, Teams and Discord, and AI agents via MCP | The Claude Code CLI, GitHub pull requests (Claude Code Review or the GitHub Action) and @Claude in Slack |
| Approves safe pull requests | Yes. Approves the lowest-risk 30–50% of pull requests under your policy; risky or uncertain ones go to a human | No. Claude Code Review leaves findings; approval stays with people |
| How risk is decided | Blends semantic LLM analysis, a custom ML model trained on your production risk signals, and static graph-based codebase analysis | LLM analysis only |
| Learns from your production incidents and reverts | Yes. Every revert or incident you record retrains your organization’s own model | Not documented |
| Blast radius of each change | Yes. A graph of your whole codebase scores how far each change reaches (blast radius) | Not documented |
| Shows its impact in numbers | Yes. Pull requests approved without a human, what was blocked at each stage, and the false-approve rate (approved changes later reverted or tied to an incident) | Not documented |
| Pricing | Free 30k reviewed LOC a month; paid from $32 for 100k LOC with unlimited users. Spend is predictable | Token-billed; Claude Code Review averages $15–25 per review and grows with pull request size |
| Git providers | GitHub, GitLab, Bitbucket, Gitea and Azure DevOps | Claude Code Review: GitHub only, Team and Enterprise plans |
| Privacy | Source-available, and can be self-hosted on the Enterprise plan so code stays in your network | Closed; code is sent to Anthropic’s cloud |
| Team-wide enforcement | At the git level for everyone, in any editor | Claude Code is a CLI for individual developers |
Most AI reviewers leave comments and stop there. LiveReview scores every pull request for risk and approves the safe ones, so your team only reviews what is risky. The approach follows Meta’s RADAR research, which reported 50× fewer production incidents, 3× fewer rollbacks and 35% faster reviews.
Bugbot is a good bug finder on pull requests. LiveReview adds the decision on top: which changes are safe to merge without a human, based on your own production history.
| LiveReview | Cursor Bugbot | |
|---|---|---|
| Review sources | Pre-commit review (git-lrc), every pull request, a PR link on the web, Slack, Teams and Discord, and AI agents via MCP | Pull requests, automatically on each update or with a “cursor review” comment; fixes open in the Cursor editor |
| Approves safe pull requests | Yes. Approves the lowest-risk 30–50% of pull requests under your policy; risky or uncertain ones go to a human | No. It posts a check that is neutral by default, so findings don’t block a merge unless you turn on failing on unresolved issues |
| How risk is decided | Blends semantic LLM analysis, a custom ML model trained on your production risk signals, and static graph-based codebase analysis | LLM bug finding, guided by your BUGBOT.md rules |
| Learns from your production incidents and reverts | Yes. Every revert or incident you record retrains your organization’s own model | Learns rules from your merged and closed pull requests; learning from production incidents isn’t documented |
| Blast radius of each change | Yes. A graph of your whole codebase scores how far each change reaches (blast radius) | Not documented |
| Try a policy on past pull requests first | Yes. Replay a draft policy on your recent pull requests before turning it on | Not documented |
| Shows its impact in numbers | Yes. Pull requests approved without a human, what was blocked at each stage, and the false-approve rate (approved changes later reverted or tied to an incident) | Not documented |
| Git providers | GitHub, GitLab, Bitbucket, Gitea and Azure DevOps | GitHub, GitLab, Bitbucket and Azure DevOps |
| Pricing | Free 30k reviewed LOC a month; paid from $32 for 100k LOC with unlimited users. Spend is predictable | Usage-based; Cursor says a review averages $1.00–1.50 and grows with pull request size, and very large pull requests are skipped |
| Source code | Whole codebase source-available, with published security scan reports; self-host with one command | Closed source, runs in Cursor’s cloud |
Bugbot is a good bug finder on pull requests. LiveReview adds the decision on top: which changes are safe to merge without a human, based on your own production history.
In-editor reviews help the person using them. LiveReview works for the whole team, at the git level and on every pull request.
Keep using in-editor reviews while you write code; LiveReview is the team-wide check before code is pushed and merged.
| LiveReview | Cursor / Antigravity in-editor review | |
|---|---|---|
| Review sources | Pre-commit review (git-lrc), every pull request, a PR link on the web, Slack, Teams and Discord, and AI agents via MCP | Inside the editor; Cursor’s Bugbot also comments on pull requests |
| Who sees the review | The whole organization, on one dashboard | Only the developer in that editor |
| Enforced for everyone | Yes. git-lrc reviews every commit, whatever editor each person uses | Only when each developer remembers to run it |
| Approves safe pull requests | Yes. Approves the lowest-risk 30–50% of pull requests under your policy; risky or uncertain ones go to a human | No |
| How risk is decided | Blends semantic LLM analysis, a custom ML model trained on your production risk signals, and static graph-based codebase analysis | LLM analysis only |
| Learns from your production incidents and reverts | Yes. Every revert or incident you record retrains your organization’s own model | No |
| Blast radius of each change | Yes. A graph of your whole codebase scores how far each change reaches (blast radius) | Not documented |
| Traceability after an incident | Every review, approval and override is recorded | No shared record |
Keep using in-editor reviews while you write code; LiveReview is the team-wide check before code is pushed and merged.
Pure LLM reviews do semantic analysis backed by broad common sense. That is one part of the RADAR/LiveReview risk score.
Local LLM reviews are still useful, and they complement a semi-automated approval system like LiveReview.
| LiveReview | Pure LLM reviews | |
|---|---|---|
| Review sources | Pre-commit review (git-lrc), every pull request, a PR link on the web, Slack, Teams and Discord, and AI agents via MCP | Wherever a developer runs it: a chat, an editor or a CLI |
| Semantic analysis of the change | Yes | Yes |
| Custom ML model trained on your production incidents and reverts | Yes. Every revert or incident you record retrains your organization’s own model | No |
| Deterministic checks customized to your repositories and organization | Yes | No |
| Whole-codebase structure and blast radius | Yes. A graph of your whole codebase scores how far each change reaches (blast radius) | No, they see the diff and nearby files |
| Risk score per pull request | Yes, and it decides which changes skip human review | No |
| Shows its impact in numbers | Yes. Pull requests approved without a human, what was blocked at each stage, and the false-approve rate (approved changes later reverted or tied to an incident) | No |
| Enforcement and traceability | Team-wide; after an incident you can trace what was reviewed and why it shipped | Depends on each person running it; no shared record |
Local LLM reviews are still useful, and they complement a semi-automated approval system like LiveReview.
Most code review tools charge more as your team grows or as token consumption fluctuates. LiveReview makes the main limit explicit: monthly reviewed Lines of Code (LOC).
You can start free with 30k LOC per month. When you need more, the paid ladder is fixed and public: 100k LOC for $32, 200k for $64, 400k for $128, 800k for $256, 1.6M for $512, and 3.2M for $1024.
Paid plans keep users unlimited, so if your team grows but your review workload stays the same, your bill does not suddenly double. That makes LiveReview predictable, workload-anchored, and easier to budget than seat-based or opaque token-based alternatives.
You can start free with 30k LOC per month. When you need more, the paid ladder is fixed and public: 100k LOC for $32, 200k for $64, 400k for $128, 800k for $256, 1.6M for $512, and 3.2M for $1024.
Paid plans keep users unlimited, so if your team grows but your review workload stays the same, your bill does not suddenly double. That makes LiveReview predictable, workload-anchored, and easier to budget than seat-based or opaque token-based alternatives.
No. You are only charged for the code that appears in the reviewed diff, not for the entire repository. A 1 million line project does not mean 1 million lines are billed. Only the code in the actual review diff counts.
Only the staged diff is analyzed. No full repository context is uploaded, and diffs are not stored after review.
git lrc hooks disable # disable for current repo
git lrc hooks enable # re-enable later
git lrc review --commit HEAD # review the last commit
git lrc review --commit HEAD~3..HEAD # review a range
Tools like SonarQube are primarily static analyzers and linters. They check code against predefined rules and usually run in the IDE or CI pipeline. Many enterprises use them to enforce quality and security standards across large codebases.
git-lrc focuses on a different layer: Git itself. Instead of analyzing the whole codebase through rule catalogs, git-lrc reviews the actual diffs at commit time. The goal is to help developers understand what changed, catch issues earlier, and attach review signals directly to the commit.
Another key difference is that git-lrc treats review as repository state. The review outcome (reviewed, skipped, vouched) becomes part of the git log, so review decisions are versioned alongside the code.
The main idea is to bring verification directly into Git, so review happens earlier and becomes part of the repository's engineering history rather than something external in CI or dashboards.
If you're interested in the broader idea behind this:
- Conjecture, Criticize, Commit: Bringing Adversarial Refutation into AI-Assisted Software Engineering
- Should Code Review Live Inside Git?
They explain the thinking behind making review a Git-native artifact rather than something that lives only in CI or dashboards.
Yes. git-lrc is free and open source — you can run micro AI code reviews on every commit without paying anything. It works with your own AI provider keys (OpenAI, Gemini, Anthropic, Ollama, and more), so usage costs are whatever your provider charges. Paid LiveReview plans exist for team-wide dashboards, repository rules, summaries, and org-wide analytics — but the commit-time review tool itself stays free.
Yes. Because git-lrc runs locally inside git itself (as a git hook, not a hosted bot), it works with any git host — GitHub, GitLab, Bitbucket, Gitea, Azure DevOps, or plain self-hosted git servers. No repository integration or bot invite is required to start.
Skipping is allowed and recorded: the commit message/log keeps a trail of reviewed versus skipped commits, so "we reviewed everything" remains verifiable instead of aspirational. Teams that want harder enforcement can use Repository Rules and CI/CD Gates in LiveReview to block high-risk changes from being skipped.
When you run a review, LiveReview only sends the diff to the AI model — nothing else. We do not store your code, and we never train any AI models on your code.
On the security side, we regularly run scans on our own codebase to catch vulnerabilities before they become a problem. This includes Gitleaks, OSV Scanner, Govulncheck, and Semgrep, all running through GitHub Actions. A Bill of Materials (BOM) is also generated and published with every release so you can see exactly what is inside.
LiveReview is fully transparent — the entire source code is available for you to browse on GitHub. You can review the full security details in the security documentation.
On the security side, we regularly run scans on our own codebase to catch vulnerabilities before they become a problem. This includes Gitleaks, OSV Scanner, Govulncheck, and Semgrep, all running through GitHub Actions. A Bill of Materials (BOM) is also generated and published with every release so you can see exactly what is inside.
LiveReview is fully transparent — the entire source code is available for you to browse on GitHub. You can review the full security details in the security documentation.
We regularly run security scans on our codebase to catch vulnerabilities early. This includes Gitleaks, OSV Scanner, Govulncheck, and Semgrep. You can check the full scan history and logs directly from our GitHub Actions page.
Self-Hosted Mode
In self-hosted mode, your team runs the entire application stack and database, and your infrastructure team controls all data storage, backups, retention, and network access.
Cloud/Provider Integrated
In cloud/provider-integrated mode, LiveReview sends data to configured external provider endpoints for AI inference and Git provider operations.
Check out more information in our deployment models documentation.
In self-hosted mode, your team runs the entire application stack and database, and your infrastructure team controls all data storage, backups, retention, and network access.
Cloud/Provider Integrated
In cloud/provider-integrated mode, LiveReview sends data to configured external provider endpoints for AI inference and Git provider operations.
Check out more information in our deployment models documentation.
Local Ollama Model
With a local Ollama model, all inference traffic stays within your own infrastructure — nothing is sent externally.
Cloud LLM
With a cloud LLM like OpenAI, Anthropic, or AWS Bedrock, the review payload is sent to that provider's API endpoint.
The choice of model is explicitly configured by the operator, ensuring complete visibility and no surprises.
With a local Ollama model, all inference traffic stays within your own infrastructure — nothing is sent externally.
Cloud LLM
With a cloud LLM like OpenAI, Anthropic, or AWS Bedrock, the review payload is sent to that provider's API endpoint.
The choice of model is explicitly configured by the operator, ensuring complete visibility and no surprises.
LiveReview has robust guardrails to prevent this. Before sending any data to the AI model, it runs prompt injection detection, neutralizes instruction override phrases (like "ignore previous instructions"), strips hidden characters, and replaces known control tokens. These checks run automatically on every review request.
Detailed information is available in our AI risks and mitigations documentation.
Detailed information is available in our AI risks and mitigations documentation.
AI suggestions are strictly advisory and require human review before any action is taken. Teams can additionally enforce branch protection, CI checks, and mandatory reviewer approvals before merging.
LiveReview also sanitizes model output before returning it, redacting sensitive patterns and handling unsafe links or HTML in the response. You can verify this in our guardrail verification documentation.
LiveReview also sanitizes model output before returning it, redacting sensitive patterns and handling unsafe links or HTML in the response. You can verify this in our guardrail verification documentation.
Yes. An SBOM is automatically generated on every release using Syft and published to the GitHub release assets. You can review it at the latest release page.
LiveReview is not SOC 2 Type II certified at this time. However, the full security documentation, scan history, SBOM, and source code are publicly available for review, giving enterprise buyers direct visibility into the security posture of the product.
Yes. You can connect your Gitea repositories in minutes and start receiving code reviews across all your projects right away.
Yes. LiveReview provides a VSCode extension. If you are using Cursor, Antigravity, or any other VSCode-based editor, you can install the LiveReview extension from OpenVSX. Find out more here.
Yes. When you try to commit through VSCode's built-in Git UI, the commit will initially fail — this is expected. git-lrc does not allow a commit to go through until the review is either completed or intentionally skipped.
To get it working, stage your files and either run
To get it working, stage your files and either run
git lrc review manually in the terminal, or click the eye icon in VSCode's Git tab. Once done, you can either commit directly from the LiveReview UI, or fix the flagged issues, stage the files again, run the review once more, and then commit through VSCode's Git UI as usual.Yes, you can mention the Livereview bot on your GitHub, GitLab, Bitbucket, Gitea, and Azure DevOps PR requests; it will automatically review all the changes and provide feedback. You can also ask further questions or debate with the AI.
LiveReview
LiveReview is the complete platform — it includes the dashboard, organization-level code review tracking, PR integration across GitHub, GitLab, Bitbucket, Gitea, and Azure DevOps, and the full suite of features for managing code quality across your entire team.
git-lrc
git-lrc is a lightweight git subcommand (
In short, git-lrc is the fastest way to get started with LiveReview and is focused on the individual developer's local workflow, while LiveReview as a platform is built for the entire organization — tracking reviews, enforcing standards, and giving managers visibility across all projects and teams.
LiveReview is the complete platform — it includes the dashboard, organization-level code review tracking, PR integration across GitHub, GitLab, Bitbucket, Gitea, and Azure DevOps, and the full suite of features for managing code quality across your entire team.
git-lrc
git-lrc is a lightweight git subcommand (
git lrc review) that brings LiveReview's AI analysis directly into your local git workflow. It runs on your uncommitted code before you push, so you catch issues at the earliest possible point. It installs with a single command and requires no Git provider connection to get started. Learn more about git-lrc here.In short, git-lrc is the fastest way to get started with LiveReview and is focused on the individual developer's local workflow, while LiveReview as a platform is built for the entire organization — tracking reviews, enforcing standards, and giving managers visibility across all projects and teams.
Yes. The LiveReview dashboard gives you a full view of all triggered code reviews across multiple projects — whether they came from GitHub, GitLab, or were triggered locally through git-lrc. This brings team standardization across your entire organization, giving managers an organization-level view of code quality, while helping developers push better code to production consistently across all projects.
Yes. If your team or organization follows specific code review practices, you can add them as instructions directly from the LiveReview dashboard. LiveReview will then check and verify that those standards are met on every code review.
LOC stands for Lines of Code. In LiveReview pricing, it refers to the code shown in the reviewed diff, not the total size of your repository.
Yes. LiveReview is powered by large language models rather than a per-language static analyzer, so it isn't limited to a fixed list of languages. It works well with Python, Java, JavaScript/TypeScript, Go, C/C++, C#, Ruby, PHP, Rust, Kotlin, Swift, and most other mainstream languages and frameworks you'll find in a typical codebase. If your team's stack includes multiple languages in the same repository, LiveReview reviews them all in the same PR without extra configuration.
The primary purpose of any code review — human, AI, or human + AI — is to deliver a better user/customer experience than your competitors can. So the honest way to evaluate a review system is by the production numbers it moves:
What RADAR adds
LiveReview rates every PR with a risk score — low, medium, or high — derived from multiple signals:
- How many production incidents per day/week/month (lower is better)
- How many deployment rollbacks per day/week/month (lower is better)
- How long a change waits to get to production (lower is better)
- How much senior engineer attention/effort each change requires (lower is better)
What RADAR adds
LiveReview rates every PR with a risk score — low, medium, or high — derived from multiple signals:
- An org-specific ML model that learns every day
- LLM semantic feedback
- Static scans + checks
At an org level, it is both safer and faster. With LiveReview's RADAR-based pipeline:
You can browse 19 examples of how LiveReview handles various scenarios in the auto-approve gallery.
- Production incidents are reduced to 1/50th of the previous rate
- Rollback rate is reduced by a third
- Wait time to merge is reduced by a third
You can browse 19 examples of how LiveReview handles various scenarios in the auto-approve gallery.
The enterprise plan is built for organizations that need more control, privacy, and flexibility. Here is what it includes:
Multiple Organization Support
Manage distinct engineering teams or entities under a single subscription.
SSO & Directory Sync
Connect your internal user directory through SAML or OIDC, so your team can log in without managing separate credentials. SCIM keeps that directory in sync: when your IdP deactivates or removes someone, LiveReview deprovisions them and revokes their active sessions immediately, and an OIDC back-channel logout cuts off a session the moment the IdP logs them out. Orgs that skip SCIM still get a periodic reconciliation check against the IdP as a fallback.
Self-Hosted Deployment
Run LiveReview entirely within your own infrastructure, keeping all your code and review data inside your network.
Custom Domain
Host LiveReview on your own company-branded subdomain.
Full Data Privacy
Complete control over where your code and review data is stored and who can access it.
Multiple Organization Support
Manage distinct engineering teams or entities under a single subscription.
SSO & Directory Sync
Connect your internal user directory through SAML or OIDC, so your team can log in without managing separate credentials. SCIM keeps that directory in sync: when your IdP deactivates or removes someone, LiveReview deprovisions them and revokes their active sessions immediately, and an OIDC back-channel logout cuts off a session the moment the IdP logs them out. Orgs that skip SCIM still get a periodic reconciliation check against the IdP as a fallback.
Self-Hosted Deployment
Run LiveReview entirely within your own infrastructure, keeping all your code and review data inside your network.
Custom Domain
Host LiveReview on your own company-branded subdomain.
Full Data Privacy
Complete control over where your code and review data is stored and who can access it.
Yes. If your team runs a private self-hosted AI model and wants to use it instead of LiveReview's default models, you can opt for the enterprise plan. Our technical support team will help you set it up on your own infrastructure.
In self-hosted mode with Ollama, the model runs entirely on customer-controlled infrastructure. The operator is responsible for choosing and managing the model. For external providers, the integration is explicitly configured, so the model being used is always known to the operator.
Enterprise customers get a dedicated SLA with guaranteed response and turnaround times for critical issues, so your team is never left waiting when something urgent comes up.
The enterprise plan is a good fit for organizations that handle sensitive codebases, require SSO for compliance, want to self-host for data privacy, or need guaranteed support response times.
Risk-aware code review is an approach that runs AI review on every change with a risk model on top — each finding is scored and prioritized by how much business damage it could cause (security, correctness, architecture, performance, compliance), instead of drowning the team in a flat list of nits. LiveReview implements risk-aware review with risk scoring, review-priority ranking, and a 10-category risk taxonomy, so engineering attention goes where the risk is highest.
A micro review is a small, fast AI code review that runs at commit time inside git — before the code lands, not after. You run
git lrc review (from git-lrc, free), the AI examines just the staged diff, and you get findings plus the option to review, vouch, or skip. Because it reviews only a small diff, it takes seconds and catches buggy logic, credential leaks, and silent behavior changes before they reach your branches.LOC (Lines of Code) means lines in the review diff only — we charge for the code that is reviewed, not for the size of your repository. A mostly stable repo with a few active files costs almost nothing; you only pay when LiveReview actually reviews changed code.
Every finding LiveReview reports is classified into a 10-category risk taxonomy: security, correctness, architecture, performance, maintainability, reliability, cost, scalability, compliance & governance, and developer experience. Categories plus per-change risk scores feed review-priority ranking, so teams can enforce rules like "no high-severity security findings may be skipped" using Repository Rules and CI/CD Gates.