Deep scans

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 recording of the real scan report page on an invented repository: the findings grouped by what they mean, each with its fix. 12 seconds, no sound.

A completed scan replaces the verdict, because a scan you asked for is a question you wanted answered:

  • evidence of malicious code turns any verdict into a block, and that one cannot be overridden;
  • a clean scan clears a warning, and clears a block you deliberately chose to interrogate. The original findings stay on the page, marked superseded by your scan — a three-day-old account with bought stars is still that, and you have decided the file evidence matters more;
  • it never clears a repository on the confirmed-malicious campaign list.

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 Hugging Face model, dataset or Space

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:

  • every file the Hub keeps outside large-file storage (configuration, tokenizer, code, model card), read in full;
  • the pickle inside each PyTorch checkpoint, and a pickle file of another kind, read by its own opcodes. Nothing is ever unpickled or loaded: a pickle that would import os, subprocess, eval and the like is a critical finding, an import outside a checkpoint's usual list is noted;
  • the header of a safetensors, GGUF or Keras file, which says what the file is. A file named as safetensors that is really a pickle or an archive is a critical finding;
  • the same engines as a repository scan over the files that were read: malware signatures, secret detection, dependency advisories and our own rules.

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.

Leaked keys

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.

Check what you built

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.

  1. Scan it. On your account page, scan a public repository you maintain. The price is shown before anything is charged.
  2. Read "What to fix first". The report ranks the findings, most serious first. Each one says where it is, why it matters, what to change and how to confirm the change. A kind of match that is often harmless is marked as that. Where RepoGates has no written fix for a rule, the report says so and leaves the line empty.
  3. Copy a fix for your own agent. "Copy this fix" puts one item on your clipboard as text; "Copy the first fixes" does the same for the top of the list. Paste it into your coding agent in your own checkout. The text tells the agent to open the file, confirm the finding is real, make the change and say what it changed. Read what the agent does with it.
  4. Scan again. The next report opens with "Since your last scan": what cleared, what is still open, what is new, and what could not be re-checked, with the reason beside each of those.

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.

What happened when agents followed the text

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.

#KindItems givenChanged in a fileLockfile change askedNot real, left aloneCould not doClearedCame in
1written to be vulnerable101not allowed1830
2ordinary21not allowed1040
3ordinary50not allowed5000
4written to be vulnerable10080216*3
5written to be vulnerable2200020
6written to be vulnerable98010130
7ordinary100100029*0
8ordinary3012030
9ordinary3201080
10ordinary3002100
All ten5714191311783

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.