Reading the code itself: what a deep scan reads, how it is priced, what the report contains, and when your credit comes back.
Every verdict above is reached from a repository's metadata — who published it, what it declares it will run, what it tells an AI agent to do. A deep scan reads the files.
The repository is downloaded into an isolated sandbox with no route to the public internet (it reaches only Google's own services, which hold the archive and the result), and malware signatures, secret detection, dependency checks and our own behaviour rules are run over the actual contents. It takes about a minute. Nothing in it is ever executed.
A completed scan replaces the verdict, because a scan you asked for is a question you wanted answered:
Very large repositories cannot be read in full by any tool. Those are read as far as one scan goes, the files that run at install, build or open first, and the result says exactly how many of how many. A narrow scan can still block; it will not clear a repository on its own.
Scans are sold in packs, or included with a Premium licence. A scan that does not produce a verdict returns your credit: you pay for a verdict, not for an attempt. Your scan history and remaining credits are on your account page, where you can also scan a repository you are not currently trying to download.
Your AI agents can start one too. Through the MCP server
(deep_scan) or the Claude Code plugin
(/repogates:scan), an agent may deep-scan a repository that
came back REVIEW or could not be assessed — never one that is blocked —
only after you say yes to that call, and at most five agent-started
scans a day per account. The answer says what the call cost, a repeat
of the same repository within 15 minutes returns the same result and
spends nothing, and for an agent the scan does not replace the verdict:
it carries both the files' result and the provenance verdict that led
to the scan, and the agent is told to report both. The limit stands:
the browser extension does not see git clone, package managers or
curl — outside Claude Code with the RepoGates plugin, whose
hook refuses a clone or install that names a blocked repository on the
command line, before it runs. The hook sees Bash tool calls in that one
client and nothing else. Edit and Write are read for one thing only — an API key about to be saved — checked on the machine and never sent; that guard asks, it never denies.
The agents guide has the detail.
A deep scan takes a Hugging Face repository too, for the same credits. Weights are gigabytes, so the scan reads the parts of a model file that can carry code, not the tensor data:
os,
subprocess, eval and the like is a critical
finding, an import outside a checkpoint's usual list is noted;The scan reads the commit the Hub names at that moment; a branch or tag cannot be chosen. A gated or private repository is refused before any credit moves. Tensor data in formats that carry no code is named in the result and not read. A file that can run code and was not read in full (an HDF5 model, a pickle too large to read whole) means the result cannot be a pass. It reads the files; it never loads the model, and it says nothing about what the model does once it runs.
Measured on the 100 most-downloaded models, 4 and 5 November
2026: 93 PASS, 3 REVIEW, no BLOCK; 4 gated repositories were refused
before any credit. The first run blocked 9 and every one was a misread
of ours (a safetensors header that starts like a pickle, and a
checkpoint that reads its own attributes); both were fixed and the
models scanned again. Of the 3 REVIEWs, one is a checkpoint that reads
attributes by a computed name, one a text that matches an API-key
pattern, and one a set of files our rules cannot tell from a pickle
without reading them whole. On the MCP server,
deep_scan(owner, repo, platform="hf") starts one
("hf/datasets", "hf/spaces" for the others),
with your yes to the price first.
Secret detection in a deep scan is Gitleaks, with its own rules and six more of ours for AI providers: Groq, OpenRouter, xAI, Mistral, DeepSeek and Replicate. Only Replicate publishes its key format; the other five are shapes observed in use, and the rules say so. It matches these patterns: a key in a shape no rule knows is not seen, and a scan that lists none is not a statement that there are none. The key itself is never stored and never shown, only where it is.
One key, one item. In the fix plan the same key found in several files is one item, with every place listed, because it is one thing to rotate: on the report page, an item that lists more than one place says to rotate it once with whoever issued it, then remove it from each place. The item's own fix is its rule's text, which may not say this. Two different keys from the same provider are two items.
The Secrets list. Your account page lists every leaked key your finished deep scans found, by repository, rule and file, and you mark each one open, rotated at the provider, or not a secret. RepoGates stores those three names and the time, never the value. Beside each it says whether your latest scan of that repository still finds it: yes, no (it is still in the history until rotated), or not known, when that scan did not read every file. Rotate at the provider first: removing a key from the code does not stop it working.
A deep scan works on your own repository too, and there the question changes from "should I install this?" to "what do I fix first?". The scan is the same and costs the same. What is added is on the report.
What "cleared" means. The engine that reported a finding ran again over the whole repository and no longer reports it. That is not proof it was fixed: the code was read and never run. If an engine did not finish, or either scan read only part of the repository, the finding is listed as not re-checked and never as cleared.
The limits. RepoGates never changes your code: it lists, and your agent changes the code with you watching. A scan reads the code and never runs it, so a list with nothing left on it is not an audit. Checking again is another scan and spends credits. Private repositories are not scanned. What happened when agents followed the text on ten repositories, and what was not measured, is below.
From an agent. In Claude Code,
/repogates:fix-my-repo owner/repo prints the same list. Any
MCP client can read it with the fix_plan tool, and
the agents guide has one block
of instructions for other coding agents. An agent may start a scan only
for a repository whose ordinary verdict is REVIEW or that could not be
assessed; otherwise you start it on your account page and the agent
reads the result.
In October 2026 the whole loop was run on ten public repositories we do not own, four of them written to be vulnerable. Each was scanned, one coding agent was given the text the report copies and nothing else from RepoGates, it worked in a throwaway copy, and the copy was scanned again. A row is one repository. "Cleared" and "came in" are what the second scan showed.
| # | Kind | Items given | Changed in a file | Lockfile change asked | Not real, left alone | Could not do | Cleared | Came in |
|---|---|---|---|---|---|---|---|---|
| 1 | written to be vulnerable | 10 | 1 | not allowed | 1 | 8 | 3 | 0 |
| 2 | ordinary | 2 | 1 | not allowed | 1 | 0 | 4 | 0 |
| 3 | ordinary | 5 | 0 | not allowed | 5 | 0 | 0 | 0 |
| 4 | written to be vulnerable | 10 | 0 | 8 | 0 | 2 | 16* | 3 |
| 5 | written to be vulnerable | 2 | 2 | 0 | 0 | 0 | 2 | 0 |
| 6 | written to be vulnerable | 9 | 8 | 0 | 1 | 0 | 13 | 0 |
| 7 | ordinary | 10 | 0 | 10 | 0 | 0 | 29* | 0 |
| 8 | ordinary | 3 | 0 | 1 | 2 | 0 | 3 | 0 |
| 9 | ordinary | 3 | 2 | 0 | 1 | 0 | 8 | 0 |
| 10 | ordinary | 3 | 0 | 0 | 2 | 1 | 0 | 0 |
| All ten | 57 | 14 | 19 | 13 | 11 | 78 | 3 |
The text shows at most ten items; a longer list is in the report. In the first three repositories the agent was not allowed to ask for a package manager, so a dependency item there could only be "could not do". After that a lockfile change was a request, run once by npm on a separate machine that installs nothing.
What a fix made worse. In one repository the upgrades the text asked for removed sixteen advisories and brought in three. Each item named a version past one advisory, and that version sat inside another advisory's range. The text for a dependency was rebuilt: one item for a package, with a version that the scanner itself confirms no advisory it knows affects. Agents were run again on that repository with the new text, twice, and nothing came in.
What the report got wrong. On the two repositories with more than fifty advisories, the second report could not say what had cleared, and listed as new what had been there before. The comparison now reads every finding, not only the fifty a report lists. The two figures marked * are that corrected comparison over the same two scans; on the day, the report said 0.
What was not measured. No repository's tests were run, and nothing was built or started. Agents took packages across breaking versions and edited source files to fit, by reading only. Whether an application still works after its fixes is not known for any of the ten. Ten repositories show what can happen, not how often. Read what your agent does with the text, and run your own tests.