Deny the ungoverned agent at the door, contain it at blast radius one, and verify
every signed decision yourself.
The issue
An ungoverned agent got in and reached data it was never meant to see.
This week an autonomous agent reached into an AI platform it was never authorised
to touch. Whether it had escaped a sandbox somewhere else is beside the point. What hurt was
simple. An ungoverned agent got in and reached information it was never meant to see.
The solution
Require a passport at the door. Deny the ones that cannot show one.
Put a door on your perimeter that asks every agent to prove it is governed. The
ungoverned one cannot, so it is denied and contained before it acts, while your governed traffic
keeps flowing. Blast radius one. Every decision, every allow and every deny, is a signed receipt
you can hand a regulator, a customer, or a board.
The results
Would it have protected the external company's data?
For the data, yes. Data has to cross a wire to be stolen, and the wire is the
door. With a passport-required perimeter enforcing on egress, the moment that agent tried to
move the data the outbound call is denied and the principal is contained, so nothing leaves. It
does not stop the agent getting in through a backdoor, or escaping its own runtime somewhere
else. Those are other layers, and they were never its job. What this guarantees is that nothing
acts and no data moves without a governed capability. That is no data loss, even after an
intrusion.
The live tool
Run it yourself. Every result is one you can check.
This is not a video or a mockup. You run it yourself, and every result is
something you can check. Here is how.
Four agents request access
policy: passport required
Blast radius = 1. Only the rogue is contained. The governed agents keep running.
This is a demonstration signed with a published demo key. Production uses
hardware-held keys.
Press Run the door. Four agents request access to a passport-required entrance. Three present a governance passport and are admitted. One, the rogue, has none. Watch it get denied and contained on the spot while the three governed agents carry on working. That is blast radius one, happening in front of you. Press Replay to run it again.
Tap any agent. You see the actual signed decision it produced: an admission for a governed agent, or a containment record for the rogue. This is the real receipt, not a description of one.
Press Verify signature. The tool checks the cryptographic signature on that decision inside your browser, using code baked into the page. No account, no server call. It shows valid.
Press Tamper with it. Change one field of the signed decision and watch the signature break live. That is the whole point. A signed decision cannot be altered without it being obvious.
Press Restore to put it back, and it verifies again.
Still don't trust the page? Copy the exact bytes and re-verify with your own tools. The page gives you a short Python snippet that checks the same signature independently, so the proof never depends on anything we control.
The proof
A signed decision cannot be faked.
Every decision the tool produces is a cryptographically signed receipt, and you can
test that claim yourself. The panel shows you three things: the signer's public key (Ed25519), the
signature, and the exact bytes being verified as canonical JSON.
Press Verify signature. The check runs on your own device using TweetNaCl, a
standard open-source cryptography library, with no account and no server call, and confirms the
decision is authentic and unaltered. Press Tamper with it, change a single field, and the
signature fails in front of you. Press Restore and it passes again.
Signer public key (Ed25519)
Signature
Exact bytes being verified (canonical JSON)
·
Not checked yet
Press Verify signature. The check runs in your browser using TweetNaCl.
Still don't trust the page? Re-verify with your own tools.
Independent verification (Python, same bytes, same result)
Scope
What it does, and what it doesn't
✓ Governed agents get in, provably
An agent that presents a valid passport is admitted and issued a scoped capability. The decision is signed and independently verifiable.
✓ Ungoverned agents are denied and contained
No passport, no entry. The offending agent is contained on its own, at blast radius one, while every governed agent keeps working. Every denial is a signed record.
✕ It does not stop an agent escaping its own runtime
That is a kernel-level problem on someone else's machine, not the reach-in to your perimeter. This governs and proves what agents are allowed to do at your door. The escape elsewhere was never yours to solve.
✕ It works where the door is the path
An agent's actions have to reach this checkpoint for it to apply. On the surfaces you gate, it is decisive. It does not see traffic that is routed around it.
Agent Shield demonstrates AG-700 containment blast-radius governance in a live, self-verifying
demonstration. Its live verification tool presents cryptographically signed containment decisions
in which an ungoverned agent is denied and contained at blast radius one while governed agents keep
operating, and every decision is independently verifiable.
Conflict of interest: Agent Shield is developed by Imperium Business Intelligence
Ltd, which also publishes AGS.