The claim
Coding agents now produce code faster than humans can review it, so security checks have to be automated and layered. Beliaev lists 12 open-source repos (vendors include OpenAI, Anthropic, NVIDIA, Microsoft, Cloudflare and Cisco) that together cover code, dependencies, secrets, running services, and the agents and skills themselves.
The list is a listicle, not an evaluation: no head-to-head results, no false-positive rates. Its value is the taxonomy, and the fact that half the entries are now LLM agents rather than rule engines.
The twelve, by layer
| Layer | Tool | Kind | What it does |
|---|---|---|---|
| Source, at PR time | Semgrep | Rules (SAST) | Pattern rules for insecure code in diffs |
| Source, at PR time | Claude Code Security Review (Anthropic) | LLM GitHub Action | Diff-aware review of each PR, comments findings, false-positive filter |
| Source, whole repo | Security Audit Skill (Cloudflare) | Agent skill, multi-agent | Six-phase audit with isolated hunters and adversarial verifiers |
| Source, whole repo | Codex Security (OpenAI) | Agent CLI, SDK, Action | Scan, validate, patch, verify fixes; SARIF export, tracker sync |
| Running app | Strix | Autonomous pentest agents | Runs the app in a Docker sandbox, proves each bug with a working exploit |
| Running app | Nuclei (ProjectDiscovery) | Template scanner | Thousands of known-vulnerability templates against live hosts |
| Dependencies and infra | Trivy (Aqua) | Scanner | CVEs and misconfigurations in images, Kubernetes, Terraform |
| Secrets | TruffleHog | Scanner | Secrets in git history, with live verification of which still work |
| Files and uploads | ClamAV (Cisco) | Antivirus | Malware in servers and user uploads |
| Agent skills | SkillSpector (NVIDIA) | Static plus optional LLM | Scans skills for prompt injection, exfiltration, excessive agency before install |
| LLM apps | PyRIT (Microsoft) | Red-team framework | Automated jailbreak and prompt-injection attacks on your LLM app |
| Release artifacts | BLA, Blind LLM Agents | Obfuscation, MCP and CLI | Makes bundles and binaries costly for AI reverse-engineering agents |
What the agent-native tools share
The four LLM-based scanners share a converging design.
Separate finder from checker. Cloudflare's skill gives every candidate finding to a fresh verifier that tries to disprove it, and a second set of fresh agents re-verifies the final records. Its principle: the agent that checks a finding is never the agent that found it. Codex Security has a separate validate step; Strix validates by exploit.
Evidence beats opinion. Strix requires a working proof of concept. Cloudflare's skill only confirms a finding with a complete source trace and an observed result; anything blocked stays
needs_validationwith the exact unresolved fact, and gets no severity.Coverage is an artifact. Cloudflare writes a
coverage-ledger.jsonand validates it with a zero-dependency script after every update; repeat runs target gaps in the ledger. Codex Security reports exclusions and coverage limits alongside findings.Repeat runs are additive. Cloudflare reports that one run found about half of what repeated runs found in total. Codex Security's Deep mode repeats Standard scans and dedupes. Treat a single LLM scan as a sample, not a census.
Structured, schema-checked output.
findings.jsonagainst a JSON schema (Cloudflare); SARIF, JSON and CSV (Codex Security, SkillSpector).Sandboxing is a precondition. Cloudflare requires an OS-enforced sandbox with no external network to run target code; without it the lead stays unverified. Strix runs everything in a Docker image.
Agent and skill supply chain
Two entries treat the agent itself as attack surface. SkillSpector scans skills before installation: 71 patterns across 17 categories (prompt injection, data exfiltration, privilege escalation, memory poisoning, tool misuse and more), a fast static stage, an optional LLM stage, a 0 to 100 risk score, and baselines so re-scans show only new findings. Its README cites a research dataset in which 26.1% of 31,132 skills had vulnerabilities and 5.2% looked malicious. It is part of NVIDIA's Verified Skills pipeline, which scans, evaluates and signs skills before publication. PyRIT attacks the deployed LLM app from outside.
Anthropic's own action carries a warning worth repeating: it is not hardened against prompt injection and should only review trusted PRs. Any LLM reviewer that reads attacker-controlled diffs with write tokens is itself a target.
Gaps and caveats
Authorization logic. A commenter points out that none of these reliably catch broken object-level authorization (BOLA), where the exploit is a valid request for someone else's object id. Rule scanners can't see it; LLM scanners can only if they know the intended access model. Codex Security's README suggests focusing scans on authentication and authorization, which helps but needs a written threat model.
Omissions. Commenters add Gitleaks (pre-commit secret blocking, complementary to TruffleHog's history scan) and Wazuh (runtime log analysis and threat detection). Runtime detection is missing from the list generally.
BLA is the odd one out. It is obfuscation against AI reverse engineering, not vulnerability finding, and its claimed 300x to 2,800x token amplification is the project's own modeled estimate.
Cost and nondeterminism. LLM scanners need API keys, minutes per scan and repeat runs to approach coverage; results differ run to run. Keep the deterministic tools (Semgrep, Trivy, TruffleHog) as the always-on floor.
Dual use. Strix and PyRIT are attack tools; run them only against systems you own, inside a sandbox.
Review checklist
Is there a deterministic floor on every PR: SAST rules, dependency and IaC scanning, secret scanning (history plus pre-commit)?
Does an LLM reviewer run only on trusted PRs, with read-only tokens, given that it can be prompt-injected?
Is every LLM finding checked by a separate agent or by an exploit before it is filed?
Is coverage recorded, so a clean report can be told apart from an unexamined area?
Are repeat or deep scans scheduled for high-value code, since one run finds about half?
Are agent skills, MCP servers and plugins scanned before install and pinned after?
Is there a written authorization model that a scanner or reviewer can check BOLA-type bugs against?
Is target code executed only in a sandbox with no external network?
Related entries
R052, Alibaba's Open Code Review: a hybrid AI code reviewer; Claude Code Security Review and Codex Security are the security-specialized form.
R064, NVIDIA SkillEvaluator: measures whether a skill helps; SkillSpector, from the same Verified Skills pipeline, checks whether it is safe.
R017, Elephant-Goldfish: fresh-context reviewers; Cloudflare's fresh verifiers apply the same idea to vulnerability findings.
R033, model supply chain: SkillSpector extends supply-chain checks from weights to skills.
R058, AI-native SDLC: security is one review pass in its PR play; this list is the tooling for it.
Sources
Stanislav Beliaev, LinkedIn post, 13 Nov 2026: https://www.linkedin.com/posts/stasbel_best-12-github-repos-to-secure-your-ai-generated-share-7527015621663035392-npoh/
https://github.com/usestrix/strix
https://github.com/cloudflare/security-audit-skill and Cloudflare's post "Build your own vulnerability harness"
https://github.com/aquasecurity/trivy
https://github.com/projectdiscovery/nuclei
https://github.com/trufflesecurity/trufflehog
https://github.com/NVIDIA/SkillSpector
https://github.com/semgrep/semgrep
https://github.com/openai/codex-security
https://github.com/Cisco-Talos/clamav
https://github.com/anthropics/claude-code-security-review
https://github.com/qybaihe/bla
https://github.com/Azure/PyRIT