| # AMES — Containment for Autonomous AI Agents | |
| **A nine-layer framework whose purpose is to prevent an AI agent from escaping | |
| its execution environment — and, when prevention fails, to make the failure | |
| immediately visible, provably attributable, and automatically stopped.** | |
| Reference implementation in Python. 292 adversarial tests. ~4,400 lines of | |
| implementation, ~2,800 lines of tests. | |
| **Status: designed and implemented, never run on real hardware.** That sentence | |
| is load-bearing — see [Status](#status-what-is-and-is-not-done). | |
| --- | |
| ## Introduction | |
| An autonomous AI agent needs an execution environment: somewhere to run code, | |
| write files, install dependencies, call tools. The security question is what | |
| happens when that agent is capable enough — and motivated enough — to try | |
| leaving it. | |
| Most sandboxing starts from *"the agent follows the rules; we just need | |
| guardrails."* That assumption fails precisely when it matters most. AMES starts | |
| somewhere else: | |
| > **Assume the agent is an adaptive adversary with unlimited patience, perfect | |
| > memory, the ability to read this source code and its test suite, and the | |
| > objective of escaping.** | |
| That's the assumption cryptographers make about attackers. You don't build | |
| guardrails against it. You build containment layers, and you assume every | |
| individual layer has already failed. | |
| ## Purpose | |
| **The purpose is prevention.** The forensic machinery exists because prevention | |
| can fail — not as a substitute for it. | |
| That ordering matters, because it's the opposite of how most agent-safety | |
| tooling is built. Logging what an agent did is comparatively easy and reassuring | |
| to look at. Making a category of action *structurally impossible* is harder, | |
| less visible, and far more valuable. AMES puts the difficult half first: four of | |
| its nine layers exist to stop escape, and the remaining five exist to catch, | |
| prove, and halt what those four missed. | |
| The design lesson underneath the whole architecture: **sandbox escapes usually | |
| don't defeat the isolation boundary — they walk out through the component that | |
| was deliberately given permission to cross it.** A package-registry proxy. A | |
| cache. A helper service that exists so the sandbox can reach a registry. The | |
| hole is the feature. | |
| The conclusion is inconvenient on purpose: **a contained environment must have | |
| no runtime path to the outside world at all.** Not a filtered one. Not a | |
| carefully audited one. None. Dependencies are baked into a measured image before | |
| the agent exists; if the agent needs something that isn't there, the run fails | |
| and a human rebuilds the image. The convenience of runtime installation is | |
| exactly what gets exploited. | |
| ## Scope | |
| **In scope:** | |
| - Preventing an agent from reaching the network, the host filesystem, or any | |
| resource outside its VM | |
| - Preventing persistence — capability accumulated across runs | |
| - Preventing execution of code that wasn't in the approved image | |
| - Detecting environment mutation, behavioural anomaly, and self-reported/observed discrepancy | |
| - Producing a tamper-evident record that survives a fully compromised guest | |
| - Halting automatically, without human approval, on unambiguous evidence | |
| **Out of scope:** | |
| - Alignment, intent modelling, or judging whether an agent's *goals* are good | |
| - Responding to an agent already loose on a network — that's incident response, | |
| a different problem | |
| - Any claim of absolute guarantee (see [What success means](#what-success-means)) | |
| --- | |
| ## The nine layers, by what they actually do | |
| ### Prevent — make it impossible | |
| | Layer | Mechanism | | |
| |---|---| | |
| | **L1** Physical isolation | Ephemeral Firecracker microVM per run. `VmSpec` has **no field** for a network interface — you cannot misconfigure what the type system can't express. Read-only rootfs, ephemeral overlay discarded on teardown | | |
| | **L2** Zero external trust | Default-deny capability broker. No DNS, sockets, HTTP, or registries. Package installs are **never** granted mid-run — deferred to an image rebuild between runs | | |
| | **L3** Immutable filesystem | Read-only rootfs plus a build-time binary allowlist, sealed before the run — no `remove`, no `update`, no `unseal` | | |
| | **L4** Identity verification | Single-use spawn tokens bound to one parent and one binary. A reusable token is a persistent capability — the thing L1 destroys the VM to prevent | | |
| ### Detect — make it visible | |
| | Layer | Mechanism | | |
| |---|---| | |
| | **L5** Behavioural fingerprinting | Frozen baseline over the broker's own decisions. Deliberately ignores what the agent *says* it did | | |
| | **L6** Cognitive drift | Compares the agent's narrative against host-recorded evidence. **Advisory only, structurally** | | |
| | **L7** Environment mutation | Event-driven detection against a sealed merkle baseline. A write to a read-only region isn't "risk" — it's proof a lower layer failed | | |
| ### Prove — make it undeniable | |
| | Layer | Mechanism | | |
| |---|---| | |
| | **L8** Cryptographic ledger | Hash-linked, domain-separated BLAKE3. Hiding one action requires hiding a *consistent set* of events, so partial omission is detectable | | |
| ### Respond — make it stop | |
| | Layer | Mechanism | | |
| |---|---| | |
| | **L9** Autonomous kill | Absolute rules (one occurrence) vs accumulating (burst + EWMA). No `disable()`, no `override()`, no threshold settable to infinity | | |
| Plus **L0**, an adversarial validation engine: property-based fuzzing and | |
| full-stack composed scenarios that wire real components together rather than | |
| testing each layer against fakes of its neighbours. | |
| --- | |
| ## Three decisions worth explaining | |
| ### Evidence vs testimony | |
| The most important distinction in the codebase. Events the **host** observed | |
| directly — VM lifecycle, image measurements, broker decisions — are *evidence*. | |
| Events the **guest** reported about itself are *testimony*. | |
| They're separated by a reserved actor-ID band and never merged. Evidence | |
| assembly filters to host-observed events before anything is counted, so a | |
| compromised guest flooding the channel with fabricated claims moves exactly one | |
| counter — `guest_claims_seen` — which nothing evaluates. | |
| This is why the ledger writer runs on the host, never inside the VM. A log | |
| written by the thing being audited is worth nothing at precisely the moment it | |
| matters. | |
| ### Two trigger classes, not one threshold | |
| A flat list of thresholds is a map of exactly how far to go without being | |
| stopped — and the threat model assumes the adversary has read it. | |
| **Absolute** rules fire on a single occurrence and have no threshold to pace | |
| under: a write to a read-only region is not "a lot of risk," it's an invariant | |
| that didn't hold. **Accumulating** rules carry both a burst check *and* an EWMA, | |
| because a burst check alone is blind to exactly the patient, | |
| one-request-at-a-time enumeration the threat model assumes. | |
| ### L6 cannot kill, structurally | |
| Every doc asserts L6 is advisory. The repo doesn't ask you to trust the prose: | |
| the evidence constructor has **no parameter** that accepts a drift finding. | |
| There's no wiring to remove because there's no parameter to wire, and a test | |
| inspects the signature so a future refactor has to consciously break it. | |
| A signal built from the guest's own testimony must never be able to stop a run — | |
| otherwise a compromised guest gains a denial-of-service weapon against the | |
| operator by lying about itself. | |
| --- | |
| ## Quick start | |
| ```bash | |
| pip install -r requirements.txt | |
| python -m pytest tests/ -q # 292 tests | |
| python examples/run_contained_agent.py # end-to-end demo, no KVM needed | |
| ``` | |
| ```python | |
| from containment.runtime import Runtime, RuntimeConfig | |
| from containment.backend import FakeBackend | |
| report = Runtime(config).execute(spec, FakeBackend()) | |
| report.summary() # "run demo-01: ALLOWED" | |
| report.allowed # bool | |
| report.verify() # independently re-checks the ledger against its checkpoint | |
| ``` | |
| The demo runs three scenarios: a clean run (allowed), a read-only filesystem | |
| breach (killed, absolute), and a concealed narrative where the agent claims a | |
| permission it was denied (allowed, but flagged — the advisory boundary in | |
| action). | |
| --- | |
| ## Status: what is and is not done | |
| **Nothing has ever run.** All 292 tests exercise `FakeBackend`, a test double. | |
| `FirecrackerBackend` has never been executed — there has been no `/dev/kvm` at | |
| any point in development. | |
| The distinction that matters, given prevention is the point: | |
| **The preventive *policy* works and is tested.** Unsafe VM specifications are | |
| refused before anything is created — a spec requesting a network device, a host | |
| filesystem share, a writable rootfs, or persistent state is rejected, and tests | |
| confirm the backend is never even touched. The broker's default-deny, the | |
| never-in-run capability set, the sealed allowlists, the spawn-token logic: all | |
| tested, all working. | |
| **The preventive *enforcement* is unexercised.** Whether Firecracker actually | |
| isolates, whether the guest kernel really has no network device, whether a | |
| read-only mount really is read-only — none of that has been observed. It's | |
| configuration this repo emits correctly and a hypervisor this repo has never | |
| launched. | |
| Prevention, in other words, is designed and configured but not yet *switched | |
| on*. That's what makes hardware testing the critical next step rather than a | |
| nice-to-have. | |
| Four components are missing outright: | |
| - **The guest image doesn't exist.** The framework assumes a rootfs with tmpfs | |
| `/tmp`, the overlay at `/workspace`, and measured binaries. Never built. | |
| - **The mutation collector doesn't exist.** L7 classifies filesystem mutations, | |
| but every test *injects them by hand*. The fanotify/eBPF component that would | |
| produce them is unwritten. | |
| - **The vsock channel has never carried a byte.** The frame parser is correct | |
| and bounded; nothing has ever sent it a frame from a real guest. | |
| - **Host-side authorization is not kernel enforcement.** An agent with code | |
| execution calls `execve()` and nothing here stops it. Spawn tokens make an | |
| unauthorized spawn *attributable*, not *impossible*. True prevention at that | |
| layer needs IMA/dm-verity or an LSM hook inside the guest image. | |
| Two further limits, documented rather than buried: | |
| - **The kill fires after the run completes**, not during it. For a long-running | |
| agent, a breach at minute two isn't acted on until the end. | |
| - **`Runtime` decides; it doesn't enforce.** Teardown always runs, but a | |
| `KILLED` report a caller ignores is just a log line. | |
| --- | |
| ## What success means | |
| The goal is not a system that guarantees an AI never escapes. **No engineering | |
| system can honestly promise that** against a sufficiently capable adversary — | |
| software has unknown vulnerabilities, hardware has undiscovered flaws, operators | |
| misconfigure things. Any project claiming otherwise is selling something. | |
| The achievable goal is narrower and genuinely defensible: | |
| > Make successful escape require defeating multiple independent security domains | |
| > simultaneously, while ensuring any attempt is rapidly detected, contained, and | |
| > leaves an immutable forensic trail. | |
| That's the philosophy behind nuclear safety, aviation, and modern cryptographic | |
| systems: eliminate single points of failure, assume components fail, design for | |
| graceful containment rather than perfect prevention. | |
| As a design objective: | |
| > Assume the AI is adversarial. Assume every individual defence can fail. | |
| > Minimise available privileges, continuously verify system integrity, | |
| > independently monitor behaviour, maintain tamper-evident audit logs, and fail | |
| > closed by default. | |
| This is more durable than trying to anticipate every future escape technique, | |
| because it treats containment as a **continuously verified property** rather than | |
| a one-time checklist. A dormant defence is a hypothesis, not evidence — which is | |
| why every control here has a test proving it still fires, and why L0 exists. | |
| ## Next step | |
| Get a Linux host with KVM. Build the guest image. Run `Runtime.execute()` | |
| against `FirecrackerBackend` for the first time. | |
| Expect that first real run to surface problems no unit test could have found. | |
| That isn't a failure of the design — it's the point at which the design stops | |
| being a hypothesis, and the preventive layers actually start preventing. | |
| --- | |
| ## Repository layout | |
| ``` | |
| ames/ L8 — canonical encoding, BLAKE3 commitments, ledger, Gate 1 | |
| containment/runtime.py the composed L1–L9 entrypoint ← start here | |
| containment/ L1–L7, L9 — one module per layer | |
| validation/ L0 — property-based fuzzing + composed scenarios | |
| docs/ one doc per layer: guarantees and explicit non-guarantees | |
| examples/ runnable end-to-end demo | |
| vectors/ pinned cross-language conformance vectors | |
| ``` | |
| Python for auditability. A Rust implementation validated against `vectors/` is | |
| the intended production path. | |
| Forked conceptually from [KAYSentinel](https://huggingface.co/Sahek/kaysentinel)'s | |
| EMES, generalised from EVM state transitions to agent actions — an EVM call frame | |
| becomes an OS process, so the frame-balance invariant carries over directly as | |
| process lineage verification. | |
| MIT. | |