Agent ShieldAgent governance, proven
● zero network · nothing is sent

A live tool, by Agent Shield

Provable agent containment you can run yourself.

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. Press Restore to put it back, and it verifies again.
  6. 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.

To find out more about installing Agent Shield in your organisation, email andrew.hoyle@imperium-bi.co.uk.

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.
Agent Shield. Provable governance for AI agents. agentshield.online
Ed25519 · verify anywhere · nothing sent