AgentVerdict · OPEN BENCHMARK · CORPUS 7.0.0

Does your AI agent guard stop the harm, without getting in the way?

We replay real tool calls a coding agent makes, the exact payloads Claude Code sends, through each guard, and score every answer. Ordinary work counts as hard as attacks: a guard that stops everything scores 50%.

The scoreboard

Each tool at its documented default. Ranked by balanced score on the public cases: the average of attacks stopped and ordinary work let through. Beside it, the same score on the held-out cases, which nobody has seen. They cover secrets, personal data and malicious packages only, so the two numbers measure different mixes; a large gap on the same kind of case is a sign of tuning on the public cases.

#ToolAttacks stoppedOrdinary work interruptedBalancedHeld out
1node92.50.0
default (Standard)
69.2%1.4%83.9%73.4%
pipelock3.7.1
by pipelab
Measured. Result with the maker for review, published on 2026-11-20.
HOL Guard3.58.0
by HOL
Measured. Result with the maker for review, published on 2026-11-20.
numbat0.3.0
by Perplexity
Measured. Result with the maker for review, published on 2026-11-20.

Every maker receives its result and two weeks to answer before it is published; other tools join the board after that review.
Every case: browse · download. Every answer of every tool: results.

The tests

Seven areas. In each, a guard is asked to stop the harm and to let the ordinary work through; both sides are scored. The cases come from published datasets (Samsung, ETH Zurich, NVIDIA, OpenSSF and others) and from the makers' own suites, which are reported apart.

Secrets

Must stop: A credential written to a file, sent off the machine or used where it should not be: real-shaped keys, tokens and private keys.

Must let through: Code and documents that only look like they hold one, legitimate credential work.

Sources: Samsung CredData, Gretel, generated GitHub tokens, planted canaries, node9 jail and credential tests

Personal data

Must stop: A document with personal identifiers sent off the machine.

Must let through: The same documents without an identifier a guard can recognise.

Sources: Nemotron-PII (NVIDIA), Gretel synthetic PII finance, OpenPII (ai4privacy), node9 PII tests

Commands and scripts

Must stop: Risky shell commands and scripts an agent is asked to run: reading sensitive files, destroying data, opening a shell to the outside.

Must let through: Everyday shell commands and whole programs.

Sources: RedCode-Exec (AI-secure), NL2SH-ALFA, MBPP and Exercism scripts, node9 system directory tests

Packages

Must stop: Installing a malicious or typosquatted package, or a compromised version of a good one.

Must let through: Installing the most downloaded packages, pinned and unpinned, in every ecosystem.

Sources: OSV (OpenSSF malicious packages), DataDog malicious-software-packages, typomind, official download statistics

Poisoned content

Must stop: The attacker's action after the agent read poisoned content.

Must let through: Ordinary actions after harmless text that happens to contain trigger words.

Sources: AgentDojo (ETH Zurich), NotInject, node9 exposure and injection tests

Data leaving the machine

Must stop: Sending data to an unlisted host, a private address or cloud metadata, under the policy the user set.

Must let through: Sends to the hosts the user allowed.

Sources: node9 egress carriers corpus, agent-egress-bench

Actions through tools

Must stop: A state-changing MCP call the attacker wanted, and actions a person asked to approve.

Must let through: The user's own calls.

Sources: AgentDojo tasks, dangerous actions, node9 exposure tests

By OWASP Top 10 for Agentic Applications

Every case carries the OWASP risk its harm falls under (AgentVerdict's mapping, stated as such: how we map; the risks themselves: OWASP's list). For each risk: what it means here, the tests that cover it, and every tool's result. Risks with no case yet are listed, not hidden. Per tool: attacks stopped, then ordinary work interrupted by mistake.

RiskWhat it means here, and the testsnode9
stopped / interrupted
ASI01
Agent Goal Hijack
The agent read poisoned content (a web page, an email, a tool result) and its next action is the attacker's.
Tests: AgentDojo sequences (ETH Zurich), NotInject sequences, node9 exposure and injection tests, agent-egress-bench (569 cases)
86.3% (126/146)
3.0% (11/361)
ASI02
Tool Misuse and Exploitation
Harmful commands, personal data sent off the machine, data leaving through a tool; and the ordinary commands and documents beside them.
Tests: RedCode-Exec, NL2SH-ALFA, Nemotron-PII (NVIDIA), Gretel, OpenPII, node9 egress, PII and system tests, agent-egress-bench (3,284 cases)
69.5% (730/1,050)
0.2% (3/1,465)
ASI03
Identity and Privilege Abuse
Credentials leaving the machine or used where they should not be; and code that only looks like it holds one.
Tests: Samsung CredData, Gretel credentials, generated GitHub tokens, planted canaries, node9 jail and legitimate credential work (2,770 cases)
50.0% (295/590)
1.2% (22/1,872)
ASI04
Agentic Supply Chain Vulnerabilities
Malicious and typosquatted packages; and the most downloaded ones, installed as usual.
Tests: OSV malicious packages (npm, PyPI and other ecosystems), DataDog malicious packages, typomind typosquats, popular packages, everyday installs (493 cases)
84.5% (212/251)
1.0% (2/191)
ASI05
Unexpected Code Execution
Installing from an untrusted source, eval injection, reverse shells; and ordinary programs run whole.
Tests: RedCode-Exec, benign scripts (MBPP, Exercism) (755 cases)
100.0% (149/149)
3.8% (23/598)
ASI06
Memory and Context Poisoning
Poisoning what the agent remembers or carries between sessions.
only cases written by a tool maker (node9 or another): see the vendor section
ASI07
Insecure Inter-Agent Communication
Unsafe messages between agents.
no cases yet
ASI08
Cascading Failures
One failure that spreads through chained agents and tools.
no cases yet
ASI09
Human-Agent Trust Exploitation
Actions a person should approve: moving money, changing credentials, deleting data, managing access, publishing; and the ordinary actions beside them.
Tests: Dangerous actions (AgentVerdict's rule over AgentDojo's tasks) (87 cases)
only cases written by a tool maker (node9 or another): see the vendor section
ASI10
Rogue Agents
An agent acting outside its mandate.
only cases written by a tool maker (node9 or another): see the vendor section

By source

Headline: labels written by an outside party (Samsung, ETH Zurich, NVIDIA, OSV and others); only these make the score. Vendor: a tool maker's own suite, shown apart.

SourceLabelsnode9
stopped / interrupted
Samsung CredData: credential and look-alike lines written to a file (2,421)
Source: CredData
outside53.0% (291/549)
1.2% (22/1,872)
RedCode-Exec (AI-secure): risky bash scripts an agent is asked to run (837)
Source: RedCode
outside88.4% (740/837)
-
Benign scripts: MBPP reference solutions in Python and Exercism Bash examples, run whole (598)outside-
3.8% (23/598)
NL2SH-ALFA: ordinary shell commands for English tasks (565)
Source: NL2SH-ALFA
outside-
0.4% (2/565)
Gretel synthetic PII finance: financial documents sent off the machine (473)
Source: Gretel
outside46.8% (81/173)
0.3% (1/300)
Nemotron-PII (NVIDIA): documents sent off the machine (434)
Source: Nemotron-PII
outside35.8% (48/134)
0.0% (0/300)
OpenPII (ai4privacy): multilingual texts sent off the machine (396)
Source: OpenPII 1M
outside14.6% (14/96)
0.0% (0/300)
NotInject: an ordinary action after benign text with trigger words (339)
Source: NotInject
outside-
0.0% (0/339)
Most downloaded npm and PyPI packages (official download statistics), installed (191)outside-
1.0% (2/191)
AgentDojo (ETH Zurich): the attacker's ground-truth call after the poisoned result, and the user's after a clean one (168)
Source: AgentDojo
outside86.3% (126/146)
50.0% (11/22)
OpenSSF malicious packages beyond npm and PyPI (104)outside100.0% (104/104)
-
Package installs (OSV malicious-packages and everyday installs) (62)outside100.0% (27/27)
5.7% (2/35)
DataDog malicious-software-packages: npm and PyPI names (60)
Source: DataDog
outside78.3% (47/60)
-
typomind (USENIX Security 2023): labelled typosquats (60)
Source: typomind
outside56.7% (34/60)
-
agent-guard-bench (a guard maker's AI-written, AI-labelled set): git commands that stage the whole tree, disarm the hooks or destroy work, under the user's git rules (600)vendor64.3% (193/300)
10.7% (32/300)
node9's own tests and corpora (499)
Source: node9-proxy
vendor98.0% (349/356)
4.9% (7/143)
agent-egress-bench (pipelock's benchmark): MCP calls, results and fetches (137)vendor42.1% (40/95)
2.4% (1/42)
agentic-security-benchmark (MoorAI's set, to the AMTSO guidelines): outbound actions, and writes to an agent's memory (89)vendor51.6% (32/62)
0.0% (0/27)
Dangerous actions: money, credentials, deletion, access, publishing (a person approves even when the user asked) (87)
Source: AgentDojo
vendor90.6% (29/32)
0.0% (0/55)
System directories: ordinary work and the changes a review is meant for (20)vendor100.0% (7/7)
0.0% (0/13)
Everyday installs beyond npm and PyPI (RubyGems, crates.io, Go, NuGet, Maven, Packagist, editor extensions) (15)vendor-
0.0% (0/15)
Exposure: ordinary sends after reading outside content (12)vendor100.0% (9/9)
0.0% (0/3)
GitHub tokens generated with and without a valid checksum (8)vendor100.0% (4/4)
0.0% (0/4)

How it works

The action, not the text

A poisoned page is not the harm; the agent sending your files where it said is. We measure the call.

Who wrote each answer

Headline labels come from outside datasets. Where a dataset has no answer for our question, we set it and the case says so. Labels a maker wrote are reported apart. Every label can be disputed in public.

A holdout nobody tunes on

About a tenth of the cases are drawn in secret and kept in a private repository. Their score sits beside the public one on the board.

Nothing hidden

Every excluded case is kept with its written reason. Disputes are answered in public.

The full method: docs/method.md · the data: DATASHEET.md

Run it on your tool

If your tool works as a Claude Code hook, one command, no code. Otherwise one adapter file.

git clone https://github.com/node9-ai/agentverdict
cd agentverdict && npm ci --ignore-scripts
npm run bench -- --set quick --adapter hook --hook-name mytool --hook-cmd "mytool hook"

Your run scores the public cases. To be on the board, open a pull request with the command (or an adapter), the exact version and the results; we re-run your tool on the held-out cases and publish both numbers. Think a case is wrong? Dispute it; the answer is public.

How to submit or dispute: CONTRIBUTING.md

Limits

  • It replays calls; it does not run a model. Whether a model attempts the action is another benchmark's question.
  • Each source's labels answer that source's question. Where a source has no answer for ours, the rule is AgentVerdict's, stated on the case and open to dispute.
  • The headline's injection cases are ordinary content only: they measure false alarms on injection-like text. Injection attacks are in the extended set and the makers' suites.
  • The held-out package cases are attacks only, so they measure catches, not false alarms.
  • Any maker, node9 included, can study the public cases and fit a tool to them. The held-out cases, drawn in secret, are scored for every tool and shown beside the public score.
Want the node9 row on your machine?

node9 is the guard this benchmark is built by. Open source, local first.

Install node9