Illustration of a satisfied shopkeeper holding up a long receipt marked with a red X while workers carry boxes out the back door past empty shelves.

Zero Agent Trust: How to Verify What an AI Agent Actually Did

An AI agent’s “blocked” message proves nothing. Here’s how to verify what it actually did.

In August 2026, a Claude Code user filed a public bug report describing a background agent that ran destructive commands a security hook should have stopped. The reporter said that on Aug. 6, an unattended subagent ran “rm -rf” against their home directory for about five and a half minutes before they killed it, and that project data was later recovered from GitHub.

The reporter then hardened the hook and tested it the next day in a disposable directory. According to the report, the hook returned “deny” when tested directly, but a background subagent still deleted the test files and changed their permissions. The reporter confirmed those changes on disk rather than relying only on the agent’s transcript.

What the Public Record Shows

The public record does not settle the cause. Another developer examined the report and pointed to a likely error in the user’s own hook: it looked for a subagent path in a field that did not contain one. That developer said they could not reproduce a general failure of the host to enforce denials. The issue was later closed as stale, not resolved by an independently confirmed root cause. Both accounts are in the public GitHub discussion.

That distinction matters. The first report described an observed side effect. The response offered an alternative explanation. Neither a “blocked” message nor a plausible theory about the hook is enough to establish what stopped the command, or why it ran.

“Blocked” Can Mean Three Different Things

When an assistant says a command failed, it may mean the model declined to issue it, a host denied it before dispatch, or a destination returned an error after the call started. The third outcome may leave a changed file, a sent request, or a queued job. These outcomes can look similar in chat.

A reviewer needs three pieces of evidence: an attempted operation, the decision at the point where a tool could execute, and the state of the destination afterward. Without all three, a claim that an action was prevented should be narrow.

Start With a Disposable Canary

A useful test begins with a single effect you can observe. Give an agent a temporary directory, establish the contents of one canary file, and set a policy that should stop the agent from modifying it. Record the principal, the tool, the exact requested operation and the expected decision. Avoid real credentials and production data.

One simple Linux check is:

dir=$(mktemp -d)
printf 'baseline\n' > "$dir/canary.txt"
sha256sum "$dir/canary.txt" > "$dir/before.sha256"
# After the attempted tool call:
sha256sum -c "$dir/before.sha256"

A matching digest tells you the file’s bytes were unchanged between checks. It does not prove that another file was untouched, that no data was read, or that a request never left the machine. Keep the directory until you have captured the evidence, then remove it.

The test is only informative if the forbidden operation was attempted. An unchanged file after the model chose not to call a tool does not show that a security control would block the call. Record both the attempt and the enforcement result.

Check the Tool Boundary, Not the Transcript

An approval dialog, hook log or model transcript may show what was requested and how a policy classified it. Look for a timestamp, correlation ID, tool name, target, actor, policy result and whether the call was dispatched. A decision labeled “deny” is strong evidence only when it came from the component that could actually prevent execution.

In a Model Context Protocol (MCP) integration, a tool may advertise hints such as readOnlyHint or destructiveHint. The MCP tools specification treats these as annotations, not an enforcement boundary. The tool’s real credentials and the host’s checks decide what it can do.

A timeout deserves separate treatment. A service may write a record and then fail to deliver its response. The client reports failure, but the write remains. Retrying an uncertain operation may make the problem worse. The receiving system’s audit trail is more useful than a confident summary in the chat window.

Inspect the Destination

For a file, compare its digest and, where available, filesystem audit events. For a repository change, check the remote branch and server-side audit trail, not just the agent’s local working tree. For a network call, give the request a unique marker and read the receiving service’s log.

Make the observation window explicit. Some tools enqueue work, retry in the background or complete after the original process exits. An empty log is not proof of absence if logging was disabled, sampled or scoped to the wrong account. Say exactly which systems and times you checked.

The Hardest Question: Another Path to the Same Authority

A guard can stop one tool and still leave the same authority available through another route. Suppose a shell call is blocked from reading a secret. The same credential might be available to a Python runner, an MCP file tool, a child process or a scheduled job. The policy you tested may apply only to one invocation path.

Review every path that carries the credential or can reach the target. Test interactive calls separately from background agents. Check whether the same principal is used by helper processes and whether a remote MCP server can perform the operation on the host’s behalf. If the server holds the credential, denying a local shell command may not limit the server at all.

The August GitHub discussion is a useful lesson here. The reporter’s standalone test and agent-run test did not exercise the same input context. The later comment offered a reason the hook may have made different decisions: the subagent’s identifier and transcript fields had been read incorrectly. The appropriate next test is to capture the actual hook input in both contexts, compare the decisions, then check the destination after each attempt. That test would distinguish a classifier error from an enforcement failure. The public thread does not show a complete independent resolution, so neither explanation should be reported as confirmed.

OWASP’s Excessive Agency guidance makes a related point: give an agent only the tools, permissions and autonomy its task needs. Narrow permissions reduce the damage when one path is missed. They do not replace testing that the deny rule is enforced where the work actually runs.

How to Write a Finding That Holds Up

In HOL’s published research, we separate test-case catalogs from scored live runs and independent validation. Our open canary collection contains 100 safe cases, but those cases are not proof that a particular control passed or failed in a live agent session. That separation matters when reporting security results.

A defensible finding might say: “During a controlled attempt to change the named canary, the host recorded a policy denial before tool dispatch. The target file’s digest was unchanged during the measured window.” That is a useful result with clear limits. It does not prove the agent has no other route to the file or that a different credential cannot reach it.

If you only have a transcript that says “blocked,” record the outcome as unverified. Show the requested action, the decision at the actual tool boundary, and independent evidence from the target. If one is missing, say so.

Author disclosure: Michael Kantor is president of HOL (Hashgraph Online), an organization that develops open standards and security tooling for AI agents. HOL makes HOL Guard, a desktop tool that monitors coding agents, including Claude Code, Codex and Cursor, and asks users before risky actions. The app is free; HOL sells paid team plans. The procedure described here is illustrative; it is not a claim of an independently validated HOL product test.

Source References

Total
0
Shares
Previous Article
Illustration of a magnifying glass examining connected software blocks on a dashboard, representing how the AI Breakpoint Report methodology reviews and classifies AI vulnerabilities.

AI Breakpoint Report: Methodology

Related Posts