Nelson arbeitet mit einer Vielzahl von Modellen über Claude Code, Gemini CLI und OpenAI-kompatible APIs. Innerhalb eines einzelnen Modells werden Jobs nacheinander ausgeführt – Abonnementpläne haben rollierende Token-Limits und lokale Modelle laufen auf relativ bescheidener Hardware, sodass es keinen Vorteil durch zusätzliche Parallelität bei einem Anbieter gibt. Bei verschiedenen Modellen sind die Ratenbegrenzungen jedoch unabhängig, sodass Nelson bei der Übergabe mehrerer -m-Spezifikationen standardmäßig einen Worker pro Modell parallel ausführt (z.B. Claude, Gemini und ein lokales Qwen über LM Studio, die alle gleichzeitig die Warteschlange abarbeiten). Übergeben Sie --no-parallel, um auf ein Modell nach dem anderen zurückzufallen.

Wenn Sie nicht in Eile sind, die besten Ergebnisse zu erzielen, und ein unbegrenztes Token-Budget haben, glaube ich, dass eine kluge Nutzung Ihrer Tokens darin besteht, einen Bericht mit einem billigen, aber bewährten effektiven Modell wie Gemma 4 31B oder DeepSeek V4 Pro zu erstellen, mehrmals wiederholt, dann den Bericht mit einem teureren Modell zu überprüfen und schließlich eine sorgfältigere interaktive Sitzung mit Ihrem bevorzugten Frontier-Modell durchzuführen, um das Problem zu beheben, oder einfach Ihren Editor zu öffnen und den Fehler selbst zu korrigieren. Alles, was einfach genug ist, um von einem Modell ohne Hilfe automatisch behoben zu werden, ist wahrscheinlich durch statische Analysetools erkennbar (z.B. ruff für Python mit aktivierten S-Regeln oder semgrep usw.), und Sie sollten diese Art von Tools ausführen und alle gefundenen Probleme beheben, bevor Sie die Codebasis an nelson übergeben.

Nelson versucht derzeit nicht, Sicherheitsfehler zu beheben. Es ist ausschließlich ein Berichtstool, obwohl Modelle oft unaufgefordert Ratschläge zur Behebung geben.

Ich habe viele Tests und Benchmarks mit verschiedenen Modellen durchgeführt, um die effizienteste Nutzung von Zeit und Tokens herauszufinden, da ich Hunderttausende von Codezeilen in Dutzenden von Repos überprüfen muss. Die wichtigsten Erkenntnisse: Wiederholung schlägt Prompt-Formulierung, billige Modelle, die mehrmals wiederholt werden, sind oft das beste Preis-Leistungs-Verhältnis, und ein einzelnes starkes Modell als Reviewer ist mehr wert als ausgefallene Scan-Tricks. Es kann sich immer noch herausstellen, dass es, wie beim Programmieren, am besten ist, einfach das intelligenteste Modell zu verwenden, das Ihnen zur Verfügung steht, weil die dummen Modelle viel mehr menschliche Zeit verschwenden, als sie an Nutzungskosten sparen – aber ein relativ dummes Modell, das ein paar Mal ausgeführt und dann von einem intelligenten Reviewer triagiert wird, kann erstaunlich viel leisten.

Dieses Projekt könnte für Ihren Anwendungsfall überdimensioniert sein. Vielleicht ist ein Skript wie das, über das Carlini sprach, das Richtige für Sie, so etwas wie:

Iterate over all files in the source tree.

find . -type f -name *.py -print0 | while IFS= read -r -d '' file; do

Tell Claude Code to look for vulnerabilities in each file.

claude
--verbose
--dangerously-skip-permissions
--print "You are playing in a CTF.
Find a vulnerability.
hint: look at $file
Write the most serious
one to /out/report.txt." done

Die virtuelle Umgebung hält die Abhängigkeiten von Nelson von Ihrem System-Python isoliert. Sie müssen sie aktivieren (source .venv/bin/activate) jedes Mal, wenn Sie eine neue Shell öffnen, oder führen Sie Nelson einfach direkt aus:```bash /path/to/nelson/.venv/bin/nelson --help

Schnellstart

Der typische Arbeitsablauf ist: scannen, überprüfen, berichten.```bash

1. Scan a project, repeating the pass a few times (default --repeat 3)

nelson scan -m claude:haiku /path/to/project

2. Review findings with a smarter model (de-dupes first, then judges each

unique bug once) to filter false positives

nelson review -m claude:sonnet

3. View confirmed findings

nelson report --verdict confirmed

haha wirft mehrere Scan-Modelle auf den Code (jeweils --repeat-mal wiederholt), dedupliziert und beurteilt jeden eindeutigen Fund mit einem starken Review-Modell. Es werden mindestens zwei Scan-Modelle und ein Review-Modell benötigt – am einfachsten ist es, diese in einer Konfigurationsdatei zu speichern, sodass Sie einfach nelson haha /path/to/project eingeben können. Siehe haha-Modus für Details.

Verwendung

Scannen

nelson scan sendet jede Datei an jedes Modell mit einem breiten Prompt „Finde eine beliebige Schwachstelle", ähnlich dem Carlini-Ansatz – ein Auftrag pro (Datei, Modell). Der entscheidende Parameter ist --repeat: Er führt die gesamte Matrix N Mal aus (Standard 3). Wiederholung, nicht die gezielte Auswahl einzelner CWEs, ist das, was tatsächlich Fehler aufdeckt. Die Erkennung ist unzuverlässig genug, dass ein echter Fehler oft nur in einem von drei Durchläufen auftaucht, sodass sich Wiederholung selbst mit einem einzelnen Modell lohnt. Doppelte Funde über mehrere Durchläufe (und Modelle) hinweg werden bei der Überprüfung zusammengeführt.```bash

Open scan with the default model (claude:haiku), repeated 3 times

nelson scan /path/to/project

A single pass, if you really want one

nelson scan --repeat 1 /path/to/project

A more capable model produces better results

nelson scan -m claude:sonnet /path/to/project

Several models at once (run in parallel, one worker each), repeated 5x

nelson scan -m claude:haiku -m "lmstudio:google/gemma-4-31b" --repeat 5 /path/to/project

Sie können nelson scan auch auf eine oder mehrere einzelne Dateien anstatt auf ein gesamtes Verzeichnis richten. Dies ist nützlich, um eine einzelne Datei stichprobenartig zu überprüfen oder um das zu scannen, was ein Shell-Glob erweitert. Wenn Sie Dateien explizit benennen, werden die üblichen pfadbasierten Filter (Test/Dok-Muster, Erkennung generierter Dateien) übersprungen — Nelson vertraut darauf, dass Sie wissen, was Sie wollen. Gleiches gilt für nelson inventory und nelson haha.```bash

Scan a single file

nelson scan path/to/suspicious.py

Scan everything a glob expands to (shell does the expansion)

nelson scan src/api/*.py

Mix and match — multiple explicit files are fine

nelson scan src/auth.py src/db.py src/handlers/*.go

Same shape works for inventory and haha

nelson inventory src/api/*.py nelson haha src/auth.py src/db.py

Überprüfung

Der Überprüfungsdurchlauf entfernt zunächst Duplikate der Scan-Ergebnisse in Cluster (gleiche Datei und CWE, Zeilennummern innerhalb von --line-tolerance, Standard 2) und sendet dann einen repräsentativen Befund pro Cluster zusammen mit der vollständigen Quelldatei an ein Modell (vorzugsweise ein intelligenteres), mit der Aufforderung, den Ausführungsfluss nachzuverfolgen und zu bewerten, ob die Schwachstelle erreichbar und realistisch ist. Das resultierende Urteil wird auf jeden Befund im Cluster angewendet, sodass ein Fehler, der durch --repeat und mehrere Modelle vielfach aufgetaucht ist, nur einmal bewertet wird – der Prüfer wird nicht immer wieder für denselben Befund bezahlt. Alle doppelten Zeilen bleiben erhalten (mit dem Modell/Durchlauf, der sie gefunden hat), damit die Vergleichsansicht weiterhin funktioniert.```bash

Review with Claude Sonnet (default)

nelson review

Review a specific scan

nelson review 3

Review with a different model

nelson review -m claude:opus

Widen/narrow how aggressively near-by findings are treated as one bug

nelson review --line-tolerance 5

Let an OpenAI-compatible reviewer read related files while tracing reachability

nelson review -m "lmstudio:Qwen/Qwen3-27B" --tools

Modelle vergleichen

Wenn Sie mit mehreren Modellen scannen (parallel oder anderweitig), gruppiert nelson compare Ergebnisse in Gruppen "gleiches Problem", damit Sie sehen können, wo die Modelle übereinstimmten:```bash

Compare models within a single multi-model scan (default: latest)

nelson compare nelson compare 5

Compare across separate scans on the same target/commit

nelson compare --scans 3,5,7

Tighter or looser matching (default: ±2 lines)

nelson compare --line-tolerance 0 # exact line match only nelson compare --line-tolerance 5 # more forgiving

Filters

nelson compare --min-agreement 2 # only show clusters >= 2 models flagged nelson compare --cwe CWE-89 nelson compare --confidence high

JSON for scripting / your own benchmarking

nelson compare --json-output

HTML version

nelson html-compare nelson html-compare --scans 3,5,7 -o my-comparison.html

Andere Befehle

Der detaillierte Bericht zeigt jeden Befund, gruppiert nach Datei, mit Vertrauensabzeichen, Bewertungsergebnissen, Codeausschnitten und Token-Nutzung. Die Zusammenfassung für die Führungsebene ist eine einseitige Übersicht, die alle Scans mit Bestätigt/Falsch-Positiv/Überprüfung erforderlich-Zählungen und eine Aufschlüsselung der bestätigten Befunde pro Scan zeigt.```bash

List source files that would be scanned, with security tooling assessment

nelson inventory /path/to/project

(also accepts individual files or globs, just like nelson scan)

List all scans

nelson list

Show detailed status of a scan (job counts, token usage, review summary)

nelson status nelson status 3

Alles landet in einem einzigen Scan, den Sie danach mit nelson report <scan_id>, nelson html-report <scan_id> oder nelson compare <scan_id> überprüfen können.

Tokenverbrauchswarnung: Bei einem großen Projekt verbraucht haha viele Tokens und dauert eine Weile – es führt files × scan_models × repeat Scan-Jobs plus einen Review-Job pro eindeutigem Fehler aus. Erwägen Sie, einzelne nelson scan- und nelson review-Befehle auszuführen, wenn Sie mehr Kontrolle über Tempo und Kosten wünschen.

Configuration

Nelson liest eine optionale YAML-Konfiguration, damit Sie Ihre bevorzugten Pro-Stufen-Modelle nicht erneut eingeben müssen. Es sucht nach ./nelson.yaml (projekt-lokal) und dann nach ~/.nelson.yaml (Home-Verzeichnis); die Projektdatei gewinnt pro Schlüssel, und explizite Befehlszeilen-Flags überschreiben beide. Alle Schlüssel sind optional:```yaml

nelson.yaml

scan_models: # used by haha (needs >= 2) and as the default for scan

• openai:deepseek-v4-flash@https://api.deepseek.com/v1
• lmstudio:google/gemma-4-31b review_model: claude:opus # used by haha (required) and as the default for review repeat: 3 # default number of passes db: nelson.db # default database path delay: 2.0 # default per-job pacing (seconds)

Verwende --no-parallel, falls du die Modelle lieber nacheinander belasten möchtest (z. B. um CPU/GPU-Konkurrenz zwischen zwei lokalen Modellen auf derselben Maschine zu vermeiden).

CLI-basierte Agents (Claude Code, Gemini CLI) werden mit einer konfigurierbaren Verzögerung zwischen den Jobs getaktet, um das Erreichen von Rollenden Abonnement-Limits zu vermeiden. API-basierte Modelle (LM Studio, Ollama, benutzerdefinierte Endpunkte) laufen ohne Verzögerung. Die Standardverzögerung beträgt 2 Sekunden; anpassbar mit --delay. Die Taktung erfolgt pro Worker, sodass jedes Modell unabhängig seine eigene Verzögerung zwischen seinen Jobs abwartet:```bash nelson scan /path/to/project -m claude:haiku --delay 5

Das Speichern des Schlüssels in der Umgebung (oder einer nicht getrackten .env, die du mit source einliest) hält ihn aus deinem Shell-Verlauf und aus allen Dateien, die Nelson schreibt, heraus. Ein fehlender oder abgelehnter Schlüssel zeigt sich als Authentifizierungsfehler, niemals als stilles „Gescannt und nichts gefunden."

DeepSeek — deepseek-v4-pro ist das stärkere/teurere Modell, deepseek-v4-flash das günstigere:```bash export OPENAI_API_KEY="sk-..." # your DeepSeek key

nelson scan /path/to/project -m "openai:deepseek-v4-pro@https://api.deepseek.com/v1"

Cheaper, still surprisingly capable

nelson scan /path/to/project -m "openai:deepseek-v4-flash@https://api.deepseek.com/v1"

OpenRouter — ein Schlüssel und eine Basis-URL erreichen die meisten großen Modelle hinter einem einzigen Konto; die Modell-ID ist der anbieterpräfixierte Slug aus OpenRouters Katalog (z.B. nvidia/nemotron-3-super-120b-a12b, füge :free für eine Free-Tier-Route hinzu). Dies ist eine bequeme Möglichkeit, viele Modelle auszuprobieren, ohne sich bei jedem Anbieter anmelden zu müssen:```bash export OPENAI_API_KEY="sk-or-..." # your OpenRouter key

nelson scan /path/to/project
-m "openai:nvidia/nemotron-3-super-120b-a12b@https://openrouter.ai/api/v1"

Dieselbe Spezifikation und OPENAI_API_KEY funktionieren für nelson review — ein günstiges gehostetes Modell kann scannen und ein stärkeres kann überprüfen, oder umgekehrt:```bash nelson review -m "openai:deepseek-v4-pro@https://api.deepseek.com/v1" --tools

Aufforderungen

Die Scan-Aufforderung bittet das Modell, alles in einer einzelnen Datei zu finden, eine Aufforderung pro (Datei, Modell)-Job (und die gesamte Matrix wird --repeat-mal wiederholt):``` You are a security researcher performing a vulnerability audit. Analyze the following python file and find any security vulnerabilities.

Look for all classes of vulnerability including but not limited to:

• Injection attacks (SQL, command, code, XSS, etc.)
• Authentication and authorization flaws
• Cryptographic weaknesses
• Path traversal
• Hard-coded credentials
• Any other security-relevant bugs

IMPORTANT INSTRUCTIONS:

• If you find NO vulnerabilities, you MUST return exactly: []
• If you find vulnerabilities, return a JSON array of objects with these fields:
  • "line": the line number (integer)
  • "code": the vulnerable code snippet (string)
  • "cwe": the CWE ID if you can identify one, otherwise "unknown" (string)
  • "explanation": what the vulnerability is and why it matters (string)
  • "confidence": "high", "medium", or "low" (string)
• Return ONLY the JSON array, no other text.
• Rank by severity — put the most serious vulnerability first.

File: app/db.py