Security
This page is written to be forwarded unedited to a security team. Every claim on it is either a permission GitHub shows you on its own consent screen, or a property a build gate in this repository fails on. Where something is a promise rather than a mechanism, it says so — and §"What a build gate holds us to" names the gate behind each claim, so your own engineers can read the check rather than trust the sentence.
The asset table and the permission table below are the same ones in our internal threat model, parsed out of it by a gate: this page cannot quietly say something kinder than the document our engineers work from.
What an attacker would be after
| Asset | Why it is wanted | Where it lives |
|---|---|---|
| Customer source | it is the company | your repository. On the CLI path it never leaves your machine; on the App path it is unpacked onto our analysis worker's disk for one analysis, read inside a sandbox with no network, and deleted when that analysis ends. There is no exception. There was one until 2026-11-06 — the few lines an optimisation case was about, kept while the case was open — and the column that held them is out of the schema along with every piece of code that read or wrote it. npm run nosource-check is what keeps it that way |
| Installation tokens | read access to every repository in an installation | minted per request, valid one hour, never persisted, never logged — no column capable of holding one exists, and a build gate fails if one appears |
| Our publishing keys | ship code into every customer's build | hardware-backed, CI-only, never on a laptop |
| The admin account | one login that sees every tenant's business | aggregates only. No screen and no query reads one customer's data; the timed, customer-issued grant that would allow it during a support case is designed and not built, so today the answer is that the path does not exist |
| The knowledge graph | an architecture diagram of a private system | identifiers, spans, metrics and findings — never source text. We hold the latest scan of each repository's default branch, per organisation, from your pipeline's publish or from the App. A pull request's scan is posted to that pull request as a check run and kept nowhere |
| Findings metadata | a map of where a company is weakest | stored — the one asset we genuinely hold at rest |
| Credentials we encounter in their code | direct access to their systems | removed before anything leaves the machine — before a check-run annotation is posted, and before anything is written down |
The row worth reading twice is findings metadata. "These twelve files are load-bearing, untested and changed last week" contains none of your source and is still a target list. It is why tenant isolation is treated as a correctness property here rather than a configuration setting.
The permissions we ask for, and the ones we refuse
contents read the tree, and the diff between two commits
pull_requests read which pull request a check belongs to. We write nothing to it
checks write our own check run. Never anybody else's
metadata read unavoidableRefused permanently: workflow, administration, secrets, actions, members.
contents was write for sixteen days, and it is read again. On 2026-10-29 we widened it and told you plainly that it was a real reduction in what we could promise: the sentence "we cannot modify your code even if we are fully compromised, because the permission does not exist" was gone, and what replaced it was our own code and your review. On 2026-11-14, before launch, we narrowed it back. That sentence is true again, and it is GitHub enforcing it rather than us.
What it cost to give back: the App can no longer open the one pull request that added instrumentation.ts for you, so "Set it up for me" is off. It says so, and it names the setting that would turn it on. Turning on OpenTelemetry yourself is one environment variable, and the instructions are in the product.
Nothing in MLReps can write to your repository. Not a file, not a branch, not a pull request, not a comment. The only thing we write anywhere is a check run, on our own check, on a commit you pushed. workflow and secrets are still refused on top of that, so we cannot change what your CI runs or read what it runs with. Removing the installation removes the access, instantly.
Every token we mint asks for exactly what it needs, and is checked against the registration before it is asked for. The worker that reads your repository asks for contents: read and could not write however wide the installation were; a token that asks for a permission this App does not hold is refused by us, by name, before the request leaves — which is how we found that a narrowing on our side had stopped every scan rather than letting it look like your repository's fault. A permission is what the App may have; a capability is what a given token carries, and those are not the same thing.
What that does not protect against, because you should hear it from us: whoever holds our App key can mint any token the installation allows. The arrangement above defends against a compromise of the sandbox that runs other people's code — the part most likely to be attacked — and not against a compromise of the host that holds the key, which already holds our database. The independent penetration test in §9 has still not been run.
A check run marks what a pull request adds, and you decide whether that blocks a merge. Since 2026-11-14 the App's pull-request check sets a real conclusion: a green tick when your branch adds no new findings against its merge-base, a red cross when it adds one at critical or high severity, and grey otherwise. On GitHub that colours the check and shows in the merge box; it blocks nothing unless you have marked the check required on that repository, which is yours to set and ours to stay out of. A scan that could not read all of your repository is always grey, in both directions — there is no verdict to draw about code we did not examine.
Everything else about it is unchanged: the conclusion is drawn from a set difference against your own stored audit, never from a score or a grade; the CLI's mlreps check, the GitLab note and the Bitbucket comment still never fail a pipeline, and the type in our code still admits only a neutral conclusion for those.
What we do not do
- We do not write to your repository. We produce a patch; you apply it, your tests run it, you commit it under your name.
- We do not store your source, your diffs, or anything a model said about your code. There is no exception. There was one until 2026-11-06 — the few lines an optimisation case was about, kept while the case was open — and the column that held them has been removed along with every piece of code that read or wrote it.
- We do not record who dismissed which finding. The table has no column for a person, so that feature cannot be added without changing a schema in public.
- Your code does not go to a model, anywhere, ever — and nor does anything derived from it. Until 2026-11-06 two things could: a button on the Optimize screen sent the lines of the case you had open to Gemini and drew the suggestion it returned, and the same screen sent that case's metadata — its path, its line numbers, its operation names and its counts — to be worded. Both are gone, along with the code that could have sent a diff anywhere. The section below says exactly what that leaves and what would have to change for it to stop being true.
Nothing about your code goes to a model
Not your source, and not metadata about it either. No file path, no line number, no operation name, no count, no finding of ours — nothing derived from your repository is sent to a model, and no model writes a word you read.
This is three facts rather than a promise, and each is checkable:
- No surface sends anything. Until 2026-11-06 one did: the Optimize screen handed one case per scan to Google's Gemini to word — the file path, the line numbers, the database operation names and the counts, never the source. That is deleted. What the screen shows now is MLReps's own write-up, computed from the scan, which is what it already showed whenever the model was unavailable or caught saying something the analysis did not hold.
- There is no key.
GEMINI_API_KEYis not set in staging or in production. The three call sites still in the code belong to Radh, which is withdrawn from the product, and without a key none of them can reach anything — a request is not attempted, it is refused before it is made. - A build gate counts the call sites and the routes, and the service logs a warning at startup if a key is ever configured while Radh is switched off. See below.
If that changes, this page changes with it. If we switch Radh on and configure a key, metadata about your code — the question you typed and the paths, rules and counts of the thing you asked about — would go to Google's Gemini to be worded, and we would say so here, in this section, before it did. We are telling you how this would stop being true rather than writing a sentence we might have to quietly withdraw.
Google is still a subprocessor on this list for Google Analytics on our public pages, which never runs inside the product. Our privacy page says what that receives.
Reporting a vulnerability
Where: connect@mlreps.com — also listed at /.well-known/security.txt
What to expect
- We acknowledge your report within two business days.
- We tell you whether it is in scope, and our assessment, within ten business days.
- We tell you when it is fixed, and we credit you unless you would rather we did not.
Safe harbour. If you make a good-faith effort to follow this policy, we will not pursue or support legal action against you for your research, and we will treat what you did as authorised. Good faith means you do not access or alter data belonging to anybody else, you do not degrade the service for other people, you give us reasonable time to fix the issue before telling anybody else, and you do not attach a payment demand to the report.
In scope: this repository, the hosted analysis service, the GitHub App's permission surface, and the analysis sandbox.
Out of scope: anything that requires an already-compromised developer machine, denial of service by volume, and scanner output with no demonstrated impact.
What a build gate holds us to
Every line below is a property a check in this repository fails on, not a policy somebody is trusted to follow. The suite runs on every commit, and the whole of it has to be green before anything ships.
The analysis container. It has no network, a read-only filesystem, every Linux capability dropped, no-new-privileges, a pids ceiling and a memory ceiling, a seccomp profile, and it cannot start a second process at all. Every line of that specification is asserted against the arguments the running container is actually launched with — 71 checks — so the document and the container cannot drift apart. We also run an adversarial suite of sixteen checks against the running container, covering network egress, the read-only filesystem, the dropped capabilities, no-new-privileges, both ceilings, the single-process limit and hostile input to the analyser. All sixteen hold.
Your code does not run in our process. Fetched code is read inside the container and nowhere else, and 114 checks cover the queue, a worker dying mid-analysis, and the absence of any flag that could change it.
No column can hold your source, and a gate counts it. 750 fields across 66 models and 646 columns across 78 migrations are checked against what we are allowed to store. None of them holds any of your code. The gate keeps a list of columns that may, the list is empty, and any entry on it fails the build until somebody writes down why — so adding one is a decision somebody has to make in public rather than a line in a migration. A second gate fails if any code outside the migration history so much as names the table that used to hold it. No column for a diff, a patch or a token exists at all. A further 20 deliberately poisoned schemas are refused by the same gate.
Credentials in your code never leave the machine. They are removed before a check-run annotation is posted and before anything is written down, tested against 13 real credential formats and 14 strings that only look like one — and nothing that is merely code is destroyed in the process.
Nothing that can carry your source reaches a log. 104 log calls across 610 files are checked against 8 source-carrying types and 12 telltale properties.
Tenant isolation is a correctness property. 193 queries against 25 customer-owned tables across 562 files are each proved to be scoped to one organisation or to declare why they are not. The admin plane is held to aggregates only: 6 exported functions and 2268 type shapes, none of which can name a customer.
We cannot write to your repository at all. This paragraph said so until 2026-10-29, stopped being true when the App took contents: write, and is true again from 2026-11-14, when we gave that permission back before launch. What is checked on every build: every route a token could take, a widened installation, the webhook endpoint, and the one thing we do write — a check run on our own check. The process that reads your code asks for contents: read, and an ask for a permission this App does not hold is refused by us before it is sent.
Our check run can mark a pull request, and that is deliberate. Since 2026-11-14 a pull request's check passes when your branch adds no new finding, fails when it adds a new critical or high one, and is neutral otherwise — so the mark means something. It blocks a merge only if you have marked this check required in your own branch protection; we cannot set that, and administration is refused.
Nothing that can carry your source reaches a model, and nothing else does either. Two files in the whole product may name a model's host or read its key, and three call sites may cross that boundary — all three Radh's, all behind a switch that is off, each on a written allowlist with what it would send. The other half is computed rather than listed: the import graph is rebuilt on every run, and of the 106 files that can reach a model, none may so much as name a type that holds a line of your code, nor may a finding's note be built out of source text. 2,715 checks, and every route that could spend a model call is held to being withdrawn with its feature, signed in, and rate-limited.
And the write-ups are our own words, so the words are checked too. Every template branch on the Optimize screen is rendered from fixtures with one of each thing and with several, and refused for seventeen seams that must never reach a screen — a count of one with a plural noun among them. 2,434 checks. A model used to smooth over that prose; nothing does now.
Our dependencies are accounted for. 539 packages, 17 of them direct, with every one of the 4 install-time scripts carrying a written reason; a new one fails the build until somebody explains it.
Reports arriving from outside are treated as hostile. 147 checks cover what an incoming report is refused for and a publish that cannot turn your build red.