CodeRabbit is using OpenAI’s GPT-6.1 Sol as the primary model in its security agent, alongside other frontier models and security tools, according to OpenAI’s October 26, 2026, case study. The deployment spans pull-request review, repository-wide Deep Scan and analysis involving linked repositories.
This is an implementation story, not a new GPT model launch. The useful detail is how CodeRabbit separates several jobs that are often bundled together under “AI security”: spotting a suspicious change, tracing its consequences through a codebase, checking whether an attacker could exploit it and preparing a fix.
CodeRabbit’s own Deep Scan announcement confirms that the feature uses frontier models, including GPT-6.1 Sol, to analyze an entire codebase, assess whether attackers could reach a flaw and suggest fixes that follow the project’s existing conventions.
My view is that the architecture matters more than the model name. A separate review agent gives teams another decision point after code has been written. Its usefulness then depends on what context it can inspect, what evidence it produces and which actions still require a person’s approval.
One Security Workflow, Several Different Jobs
CodeRabbit’s system combines continuous review of incoming changes with broader scans of committed code. Those activities cover different gaps: a pull request provides a convenient moment to catch a new issue, while a repository-wide scan can examine code that the current change never touches.
The security documentation makes those distinctions explicit.
| Stage | What it examines or does | Practical purpose |
|---|---|---|
| Pull-request security review | Security issues raised during review of proposed changes | Catch problems before merging |
| Security Architecture Review and Security Blast Radius | Changed components, trust boundaries, dependencies and downstream consumers | Explain consequences beyond an individual changed line |
| Deep Scan | Committed source code and infrastructure configuration | Find exploitable vulnerabilities and exposed secrets outside the current diff |
| Linked-repository analysis | Relevant source in connected repositories, subject to platform and plan requirements | Extend analysis beyond one repository’s boundary |
| Runtime verification and supported fixes | Reproduction steps, optional execution and remediation actions | Move a finding toward evidence and a reviewable correction |
These are related capabilities, but they are not interchangeable. CodeRabbit keeps Deep Scan results under Security > Findings, while issues raised during pull-request reviews appear under Security > PR security reviews.
That separation has an operational consequence: a team looking only at pull-request comments could miss findings from a broader scan. Someone needs responsibility for both queues.
Pull-Request Review Adds Context Around a Change
CodeRabbit includes continuous pull-request security review in its Advanced and Enterprise plans. Its documented outputs include Security Architecture Review and Security Blast Radius.
Security Architecture Review assesses implications spanning changed components, trust boundaries, controls and downstream dependencies. Security Blast Radius maps connections between a proposed change and dependencies, downstream consumers, tests and security-relevant paths. Those features are documented in the security overview.
Consider a hypothetical change that removes a permission check from a helper function. Reading the edited lines might reveal the missing check. Understanding its consequences requires knowing which request handlers call that helper, which callers already enforce permissions and which callers rely on the helper to do so.
That is the practical reason to give a security reviewer more than the diff. A locally reasonable edit can violate an assumption elsewhere.
A separate reviewer also creates some distance from the code-writing agent’s plan. I would treat that as a useful workflow boundary, not proof of independent judgment: using a second agent cannot by itself establish that the first agent’s mistake will be caught. The review still needs inspectable reasoning and meaningful enforcement.
A Finding Is Not Automatically a Merge Block
CodeRabbit offers a CodeRabbit Security check on GitHub Cloud and GitHub Enterprise Server. Teams can enable it for individual repositories and require it before merging.
The important setup detail is that publication of this check is off by default, and its default blocking threshold is Critical. These defaults are documented in the security guide.
Installing an AI reviewer therefore should not be confused with establishing a security gate. A team that wants blocking behavior needs to enable the check, configure its severity threshold and make the check required in its merge policy.
I would make that configuration an explicit rollout task. Otherwise, developers may see security comments while the repository still permits the affected change to merge.
Deep Scan Expands Coverage Beyond the Current Diff
Deep Scan analyzes committed source code and infrastructure configuration for exploitable vulnerabilities and exposed secrets. It is designed to inspect material outside the current pull-request diff.
This changes the scope of the review. A vulnerability may predate the latest contribution, sit in an infrequently edited subsystem or emerge from the interaction of several components. A workflow triggered only by changed lines has an obvious blind spot around that older code.
According to CodeRabbit’s documentation, Deep Scan findings can be inspected, triaged and exported, with supported fixes started from the findings interface. The product also includes an attack-surface map that organizes security-relevant code into subsystems and tracks verification coverage, findings and drift as pull requests merge.
The map’s practical value is in helping teams track where analysis has occurred and where changes may have invalidated previous assumptions. A clean-looking dashboard should still be read in terms of its coverage, not as a blanket statement that the application is secure.
Linked Repositories Extend Context, Not Every Kind of Scanning
OpenAI’s account describes CodeRabbit Secure analyzing linked repositories, including shared authentication libraries. That is a consequential extension for organizations that split applications, services and common libraries into separate repositories.
For example, an application may call an authentication helper whose implementation lives elsewhere. Access to that linked source could help a reviewer inspect what the helper actually checks instead of inferring its behavior from a function name. This is an illustrative use case, not a disclosed test result.
There is an important limit: Deep Scan does not perform dependency or software composition analysis, and it does not generate a software bill of materials, according to the documentation.
Those are different jobs:
- Linked-source analysis can help explain behavior across repository boundaries.
- Software composition analysis, or SCA, addresses the software components and dependencies included in a project.
- A software bill of materials, or SBOM, records that component inventory.
The distinction prevents a misleading reading of “across dependencies.” CodeRabbit can map connections and inspect supported linked source without replacing a dedicated dependency-scanning or SBOM workflow. I would keep those controls in place.
Runtime Verification Tests a Specific Hypothesis
OpenAI says users can select findings for exploit verification in an isolated sandbox. The system can then attempt to reproduce the issue and draft a proposed fix as a pull request for human review.
CodeRabbit’s documentation describes the corresponding runtime-verification capability as providing reproduction steps for Deep Scan findings, with an option to run those steps in CodeRabbit.
This introduces a useful distinction between identifying a plausible flaw and trying to demonstrate it. A static finding might describe an unsafe path through the code. A runtime attempt asks whether a particular sequence of inputs and actions can actually exercise that path in the test environment.
The sandbox is an important boundary because exploit verification may intentionally trigger unsafe behavior. Those experiments belong in an isolated environment, away from production credentials and live customer data.
A successful reproduction still needs interpretation. It demonstrates behavior under the tested conditions; it does not automatically describe every deployed environment. Conversely, a failed attempt may reflect missing configuration, inaccessible dependencies or an incomplete reproduction. I would use runtime evidence to sharpen triage, not turn a failed exploit attempt into an automatic dismissal.
Reachability and Exploitability Answer Different Questions
CodeRabbit exposes separate reachability and exploitability classifications in its pull-request security interface.
The documented reachability tiers are:
- External: reachable from an external entry point.
- Internal: reachable only from an internal entry point.
- Unreachable: no reachable path was identified.
Exploitability is classified as trivial, moderate, difficult or theoretical, reflecting the effort or prerequisites involved and the available evidence. A dash means a valid tier was unavailable from the underlying review comment, which can occur with older findings or comments without the enriched information. These definitions come from the security documentation.
Separating the two is useful. An externally reachable issue may still require substantial prerequisites, while an easy-to-trigger flaw may be limited to an internal interface. Neither label should be read in isolation from the evidence and the application’s actual exposure.
Frequently Asked Questions
4 questions
1Is CodeRabbit’s GPT-6.1 Sol integration a new model launch?
No. It is a deployment of an existing OpenAI model within CodeRabbit’s security workflow, alongside other models and security tools.
