SentraMind
← All crew Design-partner roadmap M6 AI AppSec

Reviewer

Security review of your proprietary code, on your own hardware.

What changes for the organisation

Your proprietary source code gets AI security review without ever leaving your network.

How it works

Repositories, pull requests, build artifacts, dependency manifests, API specifications, infrastructure-as-code and deployment configuration are analysed locally. Scanner findings are correlated and explained; vulnerabilities are prioritised by exploitability, reachability, exposure and data sensitivity.

What it watches
  • Approved repositories and pull requests
  • Dependency manifests, API specifications, IaC and deployment configuration
  • SAST, SCA, secret-scanning, IaC, container and API-scanner output
  • Explicitly authorised test applications, within a declared scope
Platform and code coverage

The complete web-application delivery surface

Reviewer is designed for customer-hosted Microsoft IIS and common Linux and Unix application stacks. It examines approved source, dependencies, server configuration, APIs, containers, infrastructure-as-code and build artefacts inside the customer network. Platform support means evidence from named scanners and parsers—not a claim that one model understands every stack equally.

Target support

First-wave stack for product evaluation and connector validation.

Scanner-qualified

Coverage depends on the selected engine, language, framework and available artefacts.

Custom validation

A proprietary or less common stack requires an agreed parser, connector and test corpus.

Web servers, application servers and runtimes

Platform family Servers and runtimes What is examined
Microsoft web stack Target support
IIS · ASP.NET · ASP.NET Core · Kestrel C# and VB.NET code, NuGet packages, web.config, authentication and authorization, application pools, request limits, headers and TLS.
Apache stack Target support
Apache HTTP Server · mod_ssl · mod_proxy · .htaccess Virtual hosts, enabled modules, directory access, proxy and rewrite rules, security headers, permissions and TLS.
NGINX stack Target support
NGINX · NGINX Plus · OpenResty Server and location blocks, upstreams, reverse-proxy trust, request limits, headers, TLS and Lua extensions.
Java application stack Scanner-qualified
Tomcat · Jetty · WildFly/JBoss · WebLogic · WebSphere Java and Kotlin source, JAR/WAR packages, servlet descriptors, dependencies, management surfaces and deployment configuration.
PHP application stack Target support
PHP-FPM · Apache or NGINX · Laravel · Symfony PHP source, Composer packages, runtime settings, file and upload handling, permissions and server integration.
Node.js application stack Target support
Express · NestJS · Fastify · Koa · Next.js JavaScript and TypeScript, npm packages, routes, middleware order, authentication, request handling and deployment settings.
Python application stack Target support
Django · Flask · FastAPI · Gunicorn · uWSGI · Uvicorn Python source and packages, framework settings, routes, middleware, WSGI/ASGI configuration and deployment controls.
Ruby and Go services Scanner-qualified
Rails · Sinatra · Puma · Passenger · net/http · Gin · Echo · Fiber Source, dependencies, handlers, routes, middleware, framework configuration, TLS and service deployment.
Other self-hosted servers Custom validation
Caddy · HAProxy · OpenLiteSpeed/LiteSpeed · proprietary servers Configuration, reverse-proxy policy, TLS, headers and routing after parser and connector validation.

Languages and machine-readable artefacts

Primary application languages
  • C# and VB.NET
  • Java and Kotlin
  • JavaScript and TypeScript
  • PHP
  • Python
  • Ruby
  • Go
Qualified by analysis engine
  • C and C++
  • Rust
  • Scala and Groovy
  • Lua
  • PowerShell and shell scripts
Configuration and delivery
  • HTML and server-side templates
  • SQL and migrations
  • OpenAPI and GraphQL
  • XML, YAML and JSON
  • Docker and Kubernetes
  • Terraform and CI/CD pipelines

What “support” covers

  • Source-code and pull-request analysis
  • Dependency and software-composition analysis
  • Web-server and framework configuration
  • API specification and route analysis
  • Build artefacts, containers and SBOMs
  • Infrastructure-as-code and delivery pipelines
  • Authorised, bounded and non-destructive API or DAST evidence
Offline security intelligence

Current guidance is retrieved; findings still need authority

Signed, versioned public-security knowledge packs enter the isolated environment through the governed offline update path. Reviewer retrieves the relevant records when explaining a scanner result or candidate weakness, and cites the source and pack version used.

Scanners + reproducible tests Versioned knowledge retrieval Local model explanation Human confirmation
OWASP

Top 10 classification, ASVS requirements, Web Security Testing Guide cases, Code Review Guide and defensive cheat sheets.

MITRE CWE

A stable taxonomy for the software weakness, its relationships and remediation context.

CVE + NVD

Public vulnerability identity, affected-product metadata and severity context.

OSV

Package-aware advisories and affected version ranges across open-source ecosystems.

CISA KEV

A strong prioritisation signal when a vulnerability is known to be exploited in the wild.

FIRST EPSS

Exploit-likelihood context; a probability signal, never proof that exploitation occurred.

Vendor advisories

Product-specific fixes and mitigations from the relevant server, framework and package publisher.

Scanner evidence

Normalised SAST, SCA, secret, IaC, container and API findings, preferably with SARIF or another declared format.

Retrieval comes before training. Optional LoRA adapters may learn stable security-review behaviour from evaluated, appropriately licensed public material. An advisory can therefore become usable with the next knowledge pack without a new training cycle. Customer repositories, diffs and secrets are not training data by default, and model output alone never confirms a vulnerability.

How effectiveness must be demonstrated

  • Recall on known vulnerable applications
  • False-positive rate by language and framework
  • File-and-line localisation accuracy
  • Dependency version and reachability accuracy
  • Reproducibility of confirmed findings
  • Time saved in triage and remediation
  • Percentage of model candidates confirmed by a scanner, test or person
  • Explicit gaps for generated code, missing build metadata and binary-only inputs
Reviewer scan flow

From authorised scope to a reproducible finding

Scanners supply authoritative signals, offline security intelligence supplies current context, and the local model explains intent and ranks risk. Only a scanner, a reproducible test, or a person can confirm a vulnerability.

Authoritative / reproducible Model assistance Human control Evidence record
Reviewer application-security scan flow: authorised scope enters parallel scanners, joins signed offline security knowledge and local-model assistance, passes an authority confirmation gate, then remediation, rescan and evidence recording.
Read the accessible text walkthrough

1 · Establish authorised scope

Approved repositories, server configuration, APIs, containers and build artefacts
Create a read-only, traceable application snapshot

2 · Authoritative scanners run in parallel

SAST, secret, IaC and configuration scanning
SCA, container and SBOM scanning
API, route and framework analysis
Written authority only: bounded, non-destructive DAST

3 · Normalise and correlate

Unify file, line, component, endpoint, CWE and evidence provenance

Signed offline knowledge packs

OWASP · CWE · CVE/NVD · OSV · CISA KEV · EPSS · vendor advisories
Local retrieval with source and pack-version citations

4 · Local model assists judgement

Combine reachability, exposure, data sensitivity and compensating controls
Explain risk, identify suspicious intent and recommend priority

5 · Authority gate

Confirmed by a scanner, reproducible test, or person?
Yes: confirmed finding
No: candidate for human review

6 · Remediate, rescan and record

The developer remediates; Reviewer rescans the same declared scope
Versioned finding, disposition, retest evidence and complete audit trail
How it actually works

The mechanism, not the marketing. If a step below would not survive an engineer's scrutiny, it should not be on this page.

1
Scanners run first, and stay authoritative
SAST, software composition analysis, secret scanning, IaC and container scanning all execute on the appliance. Their output — not the model's opinion — is what makes a finding a finding.
2
The vulnerability corpus arrives on removable media
CVE and NVD records, the CWE taxonomy, OSV, vendor advisories and known-exploited and exploit-likelihood data are imported as signed offline knowledge packs, verified before install and versioned like every other pack. Public data, no customer content, and no internet path into your network.
3
Retrieval before training, always
The model retrieves from that corpus at query time, so an advisory published last month is usable after the next bundle without retraining anything — and every claim cites the advisory and the pack version it came from. This is why RAG sits above LoRA in the tuning hierarchy: currency without a training cycle.
4
Adapters carry stable behaviour, never your code
Where evaluation justifies it, a LoRA adapter trains stable domain behaviour — security-review style, language-specific vulnerability patterns — on the public corpus. Your repository is not training data, by default and by design. The corpus is public; your code is not.
5
Reachability, not merely presence
A vulnerable dependency nothing calls ranks differently from one sitting on a request path. Exploitability, reachability, asset exposure, data sensitivity and compensating controls fold into one ranking, so the list is short enough for a developer to act on.
6
Intent analysis on the diff
The change is reviewed against what it claims to do: undocumented privileged paths, debug functionality, suspicious dependency additions, and changes to authentication, authorization, cryptography, input handling and logging.
7
Any active testing is scoped in writing first
Declared scope, credentials, rate limits, allowed techniques, time window, full audit trail. Non-destructive only. No exploitation, no persistence, no production scanning outside the window.

Operating path

From signal to auditable evidence

Roadmap

01Observed inputs

  • Approved repositories and pull requests
  • Dependency manifests, API specifications, IaC and deployment configuration
  • SAST, SCA, secret-scanning, IaC, container and API-scanner output

02Deterministic workflow

  1. 1 Scanners run first, and stay authoritative SAST, software composition analysis, secret scanning, IaC and container scanning all execute on the appliance. Their output — not the model's opinion — is what makes a finding a finding.
  2. 2 The vulnerability corpus arrives on removable media CVE and NVD records, the CWE taxonomy, OSV, vendor advisories and known-exploited and exploit-likelihood data are imported as signed offline knowledge packs, verified before install and versioned like every other pack. Public data, no customer content, and no internet path into your network.
  3. 3 Retrieval before training, always The model retrieves from that corpus at query time, so an advisory published last month is usable after the next bundle without retraining anything — and every claim cites the advisory and the pack version it came from. This is why RAG sits above LoRA in the tuning hierarchy: currency without a training cycle.
  4. 4 Adapters carry stable behaviour, never your code Where evaluation justifies it, a LoRA adapter trains stable domain behaviour — security-review style, language-specific vulnerability patterns — on the public corpus. Your repository is not training data, by default and by design. The corpus is public; your code is not.
  5. 5 Reachability, not merely presence A vulnerable dependency nothing calls ranks differently from one sitting on a request path. Exploitability, reachability, asset exposure, data sensitivity and compensating controls fold into one ranking, so the list is short enough for a developer to act on.
  6. 6 Intent analysis on the diff The change is reviewed against what it claims to do: undocumented privileged paths, debug functionality, suspicious dependency additions, and changes to authentication, authorization, cryptography, input handling and logging.
  7. 7 Any active testing is scoped in writing first Declared scope, credentials, rate limits, allowed techniques, time window, full audit trail. Non-destructive only. No exploitation, no persistence, no production scanning outside the window.

03Evidence outputs

  • Findings with file and line evidence, provenance, and reviewer disposition
  • Correlation between scanner output and the explanation given
  • Full audit trail for any authorised, scoped application test
This diagram describes the specified workflow; the maturity label states its current delivery status.
A case

The pull request titled “chore: bump lodash”

Two findings in one diff, produced by two different kinds of authority.

Trigger
A pull request opens. The Git host adapter delivers the diff, the manifests, and the resolved dependency tree.
Scanner finding
Software composition analysis flags a transitive dependency introduced by the bump, matched against the local OSV pack, carrying a known-exploited entry. This is authoritative: a scanner said it, and it is reproducible.
Prioritisation
Reachability analysis places the vulnerable function on a path called from the file-upload handler, which is internet-facing. That combination moves it above 40 other open findings.
Model finding
Reviewing the diff itself, the model notes a second change the title does not mention: an authentication middleware bypass added to a health-check route. It is flagged with file and line, as a candidate — not as a confirmed vulnerability.
Two kinds of confidence
The dependency finding is confirmed because a scanner and a public advisory support it. The middleware finding is unconfirmed until a person looks, and it is presented that way.
Resolution
The developer confirms the middleware change was a debugging leftover. Both are fixed in the same follow-up commit.
What it came to

Neither your source code nor the diff left the network at any point. The advisory data that made the first finding possible arrived on a USB stick last month, signed, and was verified before it was installed.

How a decision gets made

The authority ladder. Green rungs are authoritative — a rule, a scanner, a sandbox, or a person. Blue is where the model contributes. Amber is where a human decides.

01
Authoritative signal
Scanners, reproducible evidence, or human verification. A finding is not confirmed until one of those says so.
02
Bounded context
The authorised diff and its dependencies — not the repository, and never a repository the requester cannot access.
03
Model contribution
Security-focused change summaries, review of authentication, authorization, cryptography, input handling, secrets and logging changes, and detection of changes inconsistent with their stated purpose.
04
Human control
Draft remediation and regression tests with file and line evidence, for a developer to accept or reject.

What the model adds

Intent analysis — the suspicious dependency addition, the undocumented privileged path, the debug functionality that should not have shipped, the change that does not match its own commit message.

What it cannot claim

It is not the source of truth for a vulnerability, and its prioritisation is a recommendation rather than a risk decision.

What it will never do
  • Never exploits, never persists, never denial-of-service tests, and never scans outside an explicitly declared authorised scope.
  • Never treats its own assertion as a confirmed vulnerability — a scanner, a reproduction, or a person confirms it.
  • Never accesses repositories unrelated to the request.
  • Never runs a controlled DAST or API test without declared credentials, rate limits, allowed techniques, a time window and a complete audit trail.
What evidence it leaves
  • Findings with file and line evidence, provenance, and reviewer disposition
  • Correlation between scanner output and the explanation given
  • Full audit trail for any authorised, scoped application test
See it work
Not built

A specification, not a simulation

We will not show you a scripted demonstration of something that does not exist. What we publish instead is the workflow specification, held to the same standard as shipped work: actor, trigger, happy path, exceptions, terminal state, and the audit evidence it must leave. When it is built, this section becomes a demonstration.

Status and what promotion requires

Roadmap discovery. Promotion requires a named Git host and scanner formats, plus reproducibility and false-positive-rate targets.

Roles that touch it

AppSec EngineerDeveloper / Repository OwnerSecurity Engineer / Threat Hunter