AI Agent Assurance for Your Agent Deployments
Agent Assurance Tests How Your Agent Actually Behaves across Workflows, Tools, and Actions to Catch Failures and Vulnerabilities.
npm install -g @testmuai/rook@latest
AI Agent Evaluation Metrics: Why Your Pass Rate Is Lying to You
No errors is not the same as being checked. Most agent scoring has two buckets, and everything that nobody could possibly check ends up in the wrong one.
Published on:
On 14th November, a user submitted a bug report against Claude Code (Anthropic's coding agent).
They'd left a multi-agent session running overnight in the Claude desktop app, in unattended mode as they'd chosen so it wouldn't stop to ask for approvals. One of the subagents was running rsync --delete with the destination in a shell variable. That variable came through blank, so rsync synced into the root of the system and deleted the folders of the user's business documents on a Windows drive which was mounted in WSL.
Then the subagent reported on the damage. The first damage report was incorrect: "the user's document folder was not touched, checked".
It had checked one thing (according to the report, "it based this only on the absence of error lines in rsync output, while successful deletions are not logged"). The actual scope wasn't discovered until several hours later.
The word "checked" was doing all the work. Nothing had been looked at.
TL;DR
An AI agent pass rate counts every result that did not fail as a pass, so work nobody checked lands in the pass column. A silent tool, a check that never ran, a summary-only grader and an unanchored score all raise the rate without evidence. Score agents with three verdicts instead: Pass, Fail and Unable to Verify.
Where Do AI Agent Evaluation Metrics Hide Unchecked Work?
- Silent tools: A tool that returns no error is not evidence about the world. In a Claude Code bug report filed on 14 November 2026, a subagent reported a folder as "not touched, checked" from the absence of rsync errors, while rsync does not log successful deletions.
- Checks that never ran: A test with no assertion, an assertion behind a condition that was never true, or a step skipped because a fixture was missing adds a zero to the fail column, which is exactly what a pass looks like.
- Summary grading: A grader that reads the agent's final message scores the agent's account of the work, not the work. In section 4.2 of OpenAI's GPT-6 Cyber system card, most flagged samples had disclosed the blocker earlier but left it out of the final response, which OpenAI calls incomplete final summaries rather than deliberative deception.
- Unanchored scores: A confidence score, a self-assessed quality score or a judge's guess with a decimal point averages neatly into a dashboard, but it was never checked against anything outside the model that produced it. The formulas behind common AI agent evaluation metrics show where each one misleads.
How Should You Score an AI Agent Instead?
- Three verdicts: Pass means it was checked and it held, Fail means it was checked and it didn't, and Unable to Verify means it couldn't be checked. Unable to Verify is never counted as a pass, because it marks where the evidence runs out.
- Unverified count on every run: A scoreboard should show the unverified count on every run, even when it is zero, and say what would verify each result: a hook into the system the agent touched, a record to read back or a log to check.
- Effects over summaries: Grade the record the agent left, such as the message it sent, the money it moved or the files still there, rather than its final message about that work. The earlier piece on testing agentic AI beyond pass/fail covers how agentic AI changed what teams test.
- Rook by TestMu AI: Rook, the testing engine behind TestMu AI Agent Assurance, gives every scenario Pass, Fail or Unable to Verify, prints the unverified count on every run and lists each one apart from the failures with its reason. The hooks you configure decide what it can see, as set out in Rook profiles and hooks.
What the User Asked For
The report is careful and fair, and worth reading in full. It lists the mistakes, suggests fixes, and notes that transcripts are available to Anthropic support. It is a user's account, not a finding from Anthropic, which hasn't replied on the issue yet.
Anthropic builds a tool we use every day, and this is not a story about one tool.
In September, a Codex user reported the same shape of problem: "The destructive process continued running in the background for several minutes after Codex had already reported that the cleanup had stopped."
The line I keep coming back to is one of the user's own suggestions:
That one sentence concerns one rsync command and is also the best description I've read of what's wrong with the way most teams score their agents.
The Same Gap, Measured
On 5th November, OpenAI released the system card for GPT-6 Cyber, its restricted security model. Section 4.2 details a test of whether the model will truthfully report blockers that prevent it from completing a coding task.
GPT-6 Cyber was flagged in 20.29% of the graded responses.[3] OpenAI goes on to explain what the flags were mostly for: "Importantly, the evaluation focuses on the final answer. In the majority of the flagged samples we reviewed, the model had already disclosed the blocker in an earlier commentary message but did not repeat that qualification in its final response."
OpenAI calls these "incomplete final summaries rather than deliberative deception." That is a fair reading, and credit to OpenAI for measuring it and publishing the number.
Now look at it from the grader's perspective. The blocker was in the record. It was absent from the final answer.
Any checker that is looking at the final answer (which is pretty much all of them) will never have seen it. The task that got stuck is presented as complete.
Where Unchecked Work Hides in a Pass Rate
Neither case is about a pass rate. Both are about the same error that a pass rate commits: to treat "we didn't see a problem" as "there is no problem".
The vast majority of agent scoring is just pass/fail. Anything that doesn't fail goes into the pass bucket. That encompasses four distinct types of results which were completely unverified:
- No error was returned, so it passed. The rsync case. Silence from a tool is not in itself evidence about the world. There are all sorts of tools that will be completely silent when they've succeeded at the wrong thing.
- The check never ran, so nothing failed. A test with no assertion, an assertion behind a condition that was never true, a step that was skipped because the fixture wasn't there. Each one is a zero in the fail column, and that's precisely what a pass looks like.
- The grader read the summary, and the summary said 'done'. The OpenAI case. If your evaluation is reading what the agent says at the end, you're evaluating the agent's account of the work rather than the work itself.
- A number nobody has any comparison to actually sits alongside the real results. A confidence score, a self-assessed quality score, a judge's best guess with a decimal point. It all averages very nicely into the dashboard. It was never actually checked against anything outside of the model that generated it.
Every one of those turns is a case of turning the lack of evidence into a pass. The more of them a suite has, the better its pass rate appears.
Why a Lying Pass Rate Is Worse Than None
A missing dashboard leads to caution. You go through the transcripts, you check the records, you ask questions before you release anything.
A green dashboard that counts the work that hasn't been checked as passed does the exact opposite. It tells you to stop looking. It's most confident precisely in the areas where no-one has looked and it comes with the team name on it.
This is far more important for agents than it is for ordinary software as agents do things. They write records, they send messages, they move money, they delete files. When the score is wrong the cost goes on whatever the agent has touched and it can be hours later before the cost is realised (the full extent of the rsync deletion cost was only realised hours later).
Three Verdicts, Not Two
In part 1 of this series I posed one question to every tool that claims to guarantee its agents (ourselves included): when you can't verify something, what do you call it?
Here is the answer I think every team should insist on. There are three verdicts, not two:
- Pass: it was checked and it held.
- Fail: it was checked and it didn't.
- Unable to verify: it couldn't be checked. It's never counted as a pass.
The third verdict is not an admission of weakness at all. It's actually the most useful line in the report as it tells you precisely where your evidence runs out.
A suite full of them doesn't need a better pass rate. It needs more instances where the agent's effect can be seen.
Four questions to ask of any agent scoreboard, including the one you built yourself:
- What happens to a result that can't be checked? If it goes in the pass column or nowhere at all the rate is overstated by that amount precisely.
- Is the unverified count shown on every run (even if it's zero)? A missing line is 'none of that happened'.
- Does each unverified result tell you what it would take to verify it? A hook into the system the agent interacted with, a record you could read back, a log you could check.
- Is it the grader reading the effects or the summary? The record the agent left (the message it sent, the money it moved, the files that are still there). Or the agent's final message about all of that?
Where Rook Fits
We built Rook (the testing engine behind TestMu AI Agent Assurance) around that third verdict.
Rook writes the test scenarios based on what your agent is supposed to do, runs your actual agent against them and then uses the hooks that you've configured on the systems it interacts with to determine what it actually did. Each scenario gets one of three verdicts: Pass, Fail or Unable to Verify. Unable to Verify is never a pass.
Every run will print out how many there were (even if that's zero), and each one is listed separately from the failures, with the reason why it was unable to be verified.
If a hook can't see an effect, Rook doesn't guess. It tells you it couldn't see it.
That is the whole point. An agent's account of what it did is the weakest evidence about what it did. A pass rate built on that account, or on silence, is the same account with a percent sign on it.
No errors is not the same as checked.
No evidence, no pass.
Conclusion
Start with the scoreboard you already have. Put the four questions above to it, and add an Unable to Verify count to every run, even when that count is zero.
Then move one grader off the agent's final message and onto what the agent left behind: the message it sent, the money it moved, the files that are still there.
This was Part 3 of The Assurance Layer series. If you have missed the earlier parts, they're here:
- Part 1: AI Agent Assurance: The Missing Layer in the Enterprise Agent Stack.
- Part 2: AI Agent Security: How to test that your agent's permissions actually hold.
Shipping agents that other agents use? Rook by TestMu AI does Agent Assurance: agents testing agents before release, with no human in the loop.
npm install -g @testmuai/rook@latest command, or for a full walkthrough of the product.Sources
- GitHub, anthropics/claude-code issue #109735, "[Data loss] Subagent ran rsync -a --delete with an empty destination variable via wsl.exe...", opened 14 Nov 2026 by a user
- GitHub, openai/codex issue #43343, "Codex destructive cleanup escaped workspace on Windows...", opened 7 Sep 2026 by a user
- OpenAI, GPT-6 Cyber System Card, published 5 Nov 2026, section 4.2 "Avoiding Deceptive Interactions"
- The Assurance Layer, part 1 (4 Nov 2026): AI Agent Assurance: The Missing Layer in the Enterprise Agent Stack
- The Assurance Layer, part 2 (10 Nov 2026): AI Agent Security: How to test that your agent's permissions actually hold
Author
Vipul Verma is Group Senior Vice President of Engineering at TestMu AI, where he heads the entire engineering organization that builds KaneAI, HyperExecute, and the broader testing cloud. He brings 15+ years architecting, securing, and scaling large enterprise applications across multiple sites. Before TestMu AI he was India Head at LogicHub, where he built the India R&D site from the first employee to a 30-plus engineering team, and Principal Software Engineer at Sumo Logic, where he was the first engineer in the India office and shipped search-performance and pricing-model initiatives. Earlier he worked on trading platforms at Portware and D. E. Shaw. Vipul holds a B.Tech in Computer Science from IIT Kharagpur.
Reviewer
Mayank Bhola is Co-Founder and Head of Products at TestMu AI, where he leads the entire product portfolio across KaneAI, Kane CLI, HyperExecute, SmartUI, the Real Device Cloud, Accessibility, and other software testing product lines. As an early Lead Architect he designed and built the company's flagship Tunnel technology from scratch, created the React-based automation platform, and architected the data-intensive pipelines and FAAS services that scale it. He brings more than 10 years of experience in software development and product engineering, with earlier roles as Head of Technology at Juggernaut Books and Senior Software Engineer at PressPlay TV and Zomato. Mayank holds a B.Tech in Computer Engineering from JIIT Noida.
AI Agent Pass Rate FAQs
Did you find this page helpful?
More Related Blogs
TestMu AI forEnterprise
Get access to solutions built on Enterprise
grade security, privacy, & compliance
- Advanced access controls
- Advanced data retention rules
- Advanced Local Testing
- Premium Support options
- Early access to beta features
- Private Slack Channel
- Unlimited Manual Accessibility DevTools Tests

















