Dev.to Security πŸ” Cybersecurity πŸ‘ 0 πŸ“– 5 min read

My agent called a tool I never approved and I found out after: pre-call policy plus post-call proof

My agent called a tool I never approved and I found out after That is the failure mode nobody demos. The agent finishes, the summary sounds fine, and only later do you learn it called a tool you never approved, wrote s

My agent called a tool I never approved and I found out after

That is the failure mode nobody demos. The agent finishes, the summary sounds fine, and only later do you learn it called a tool you never approved, wrote state you never reviewed, or spent against a limit you never set. By then the call already landed. A log line is not a gate, and a confident summary is not proof.

On November 20, 2026, a job on Zambo got checked from both ends by two independent systems, and I can show you both checks with the actual artifacts. Before the call: HOL Guard, an outside policy engine from Hashgraph Online, evaluated the call against a published descriptor. After the call: a verifiable receipt under AER-1, the agent execution receipt standard, let anyone recompute whether the saved result was changed. Brennan Zambo built Zambo and created AER-1; neither check trusts the other, and neither trusts Zambo's own say-so. That independence is the whole point.

What shipped that morning

Michael Kantor merged pull request #8162 into hashgraph-online/hol-guard on 2026-11-20T17:25:41Z. The PR added one file that matters here: contributions/mcp-servers/mcp.zambo.json, a descriptor that classifies all 37 tools on the default Zambo surface at https://zambo.dev/mcp.

The classification is plain:

  • Reads inherit. Price lookups, status checks, memory recall, capability search, handover status: the Guard leaves host policy alone.
  • Writes go to review. Handover create and accept, workflow close, session and thread creation, spend limit changes, Day Pass actions, and the universal tool all pause for a human decision.
  • Nothing is blocked outright. The descriptor tightens, it does not ban.

If you run agents against any MCP server, that split is the part worth copying. Reads are cheap and reversible. Writes, handovers, and spend are where an unapproved call actually costs you something, so those are the calls that should wait for a review decision before they run.

The first test, run the same day

Kantor named the first test himself: run a covered call against the live surface and confirm it leaves its receipt, then run a call outside the descriptor and confirm it stops before it lands. We ran exactly that against the released hol-guard 3.60.0 runtime, with the merged descriptor dropped in byte-identical to main.

Leg 1: a covered call runs, and leaves proof

Call: live_price for BTC. The descriptor lists it as a read, so it inherits. The runtime decision was ALLOW. The call ran against https://zambo.dev/mcp and returned BTC at $58,757.91.

Receipt: https://zambo.dev/run/c6d00ccf-2af4-44dc-9c85-305ee3e031a3

Then the after check. Take the receipt's canonical bytes, hash them with SHA-256, and compare against the output_hash recorded in the receipt. In this run the recomputed hash matched: MATCH, verification status commitment_matches. That is all a verifiable receipt claims, and it is enough: the saved result was not changed after the fact. It does not claim the price was right. It proves the record you are checking is the record the job produced.

Leg 2: an unlisted call stops before it lands

Call: signal_lookup. It exists on the full 153 tool surface, but it is not one of the 37 tools the descriptor lists, so it falls to the descriptor's catch-all row. The runtime decision was REVIEW, source catalog-mcp-extension, before anything was sent.

Nothing was transmitted for this leg. The only tools/call sent in the entire run was the covered one, so no receipt exists for signal_lookup, and that absence is the evidence. The call did not land and then get flagged. It stopped at the gate.

Run the same check yourself

You do not need to take this article's word for any of it. Three steps, in order:

  1. Read the descriptor. Open contributions/mcp-servers/mcp.zambo.json in hashgraph-online/hol-guard on main. Every one of the 37 default tools is listed with inherit or review, plus the catch-all row that caught signal_lookup. If a tool your agent uses is missing from a descriptor like this, assume it falls to the catch-all and decide whether review is the behavior you want.

  2. Evaluate before you execute. Point HOL Guard at the call your agent is about to make and read the decision first: allow, review, or block, and which rule produced it. In the Nov 20 run that single step is the difference between leg 1 and leg 2. One call proceeded, one never left the machine.

  3. Recompute the receipt after. Fetch the receipt JSON for a finished job, take its canonical bytes, run SHA-256 over them, and compare the result to the receipt's output_hash. Equal means the saved result was not changed. Not equal means you are looking at a different record than the one the job produced, and you found out by math instead of by trust. The AER-1 corpus behind this check currently runs 143 vectors and 146 checks, and independent implementers have rebuilt verifiers against it, so your recompute does not depend on Zambo's own verifier agreeing with itself.

Why both ends, not one

A pre-call gate alone leaves you trusting the result once the gate opens. A receipt alone leaves you auditing damage after an unapproved call already ran. Together they cover the job: policy decides what may run, proof shows what did run and whether the record survived intact.

The scale here is not hypothetical. As of November 20, 2026, Zambo has issued 154,221 verifiable receipts, and the agent packages that teach this pattern have been downloaded 338,958 times. Every one of those receipts is checkable the same way leg 1 was checked above.

One practical note for the review path. When a write or handover call passes review mid-job, you want the job to finish in the same session instead of stalling at a free limit with the work half wrapped. That is what the Day Pass is for on Zambo: $0.99 for unlimited calls for 24 hours, so an approved job completes and seals its handover in one run. It solves the stall, which is the actual problem the gate creates, and it is the only purchase this workflow ever asks for.

The takeaway for your own stack

If your agent calls tools you care about, steal the shape, not the brand:

  • Publish a per-server descriptor that classifies every tool, reads apart from writes, with a catch-all row for anything unlisted.
  • Evaluate the call before it runs, and treat review as a stop, not a warning.
  • Require a verifiable receipt for finished work, and recompute it from the canonical bytes before you rely on it.

Brennan Zambo, Zambo, and AER-1 are the names on this instance of the pattern: the person who created the agent execution receipt category, the product where it runs in production, and the open standard anyone can implement. HOL Guard is the independent half that made the before check real on November 20. Two systems, built by different people, checking the same job from opposite ends. That is what approved and proven actually looks like.

πŸ“° Read the original article on Dev.to Security

Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes β€” full credit and traffic to the original publisher.