CVE-2026-80521 is an ordinary Linux kernel race in Unix-domain-socket garbage collection. It is not an AI vulnerability, and no intent system would somehow “fix” it. That is exactly why it is useful.
The agent stack is increasingly being built on long-running sandboxes, microVMs, persistent sessions, checkpointed execution, and managed runtimes. Those systems inherit every ordinary failure mode of the infrastructure beneath them: kernel bugs, restarts, stale state, snapshots, migrations, host replacement, and recovery.
At the same time, the major runtime platforms are getting much better at keeping agents alive through those failures.
NVIDIA OpenShell can run workloads across Docker, Podman, Kubernetes, and microVM backends while preserving a common sandbox abstraction and centralized policy. NVIDIA Docs Google Agent Substrate is explicitly designed to suspend idle agents, snapshot guest state, release compute, and resume the same sandbox in under 500 milliseconds. Google Cloud Amazon Bedrock AgentCore supports persistent runtime instances for workflows that may run for hours or days, shared state, collaborating agents, and managed snapshots. Amazon Web Services, Inc. Microsoft Foundry Hosted Agents gives each session an isolated sandbox with durable state and filesystem persistence, and is designed to survive container crashes, redeployments, and periods of inactivity. Microsoft for Developers
This is a remarkable amount of engineering around one question:
How do we preserve execution?
The harder question is still under-specified: How do we preserve the current authority of the objective when execution moves, restarts, forks, sleeps, or comes back from the past?
That is the problem Intent Containers are meant to solve.
We are getting very good at preserving the wrong thing
Google’s Agent Substrate is a good example. Its purpose-built control plane can snapshot a sandbox to local disk and Cloud Storage, release the CPU and RAM, then restore the agent later with its state intact. Google Cloud Operationally, that is exactly what long-running agents need.
Now imagine the agent is suspended while it has temporary authority to remediate a production system. While the agent is asleep, that authority is revoked. An hour later, the runtime restores the old snapshot. The runtime has done its job perfectly. Memory is back. Local files are back. The agent can continue exactly where it left off.
But the restored execution contains a historical view of the world. The organization’s authority state has moved on. The restored workload should not get to decide which version wins. That single case exposes a broader design problem. Execution state and authority state have different clocks. A snapshot is supposed to preserve the past. Authorization is supposed to reflect the present. If those two are stored in the same place, recovery can quietly become privilege resurrection.
This is the invariant we have been using in our Intent Containers work: Execution state can travel backward in time. Authority cannot.
AWS and Microsoft make the same tension visible from another direction
Amazon Bedrock AgentCore is moving toward more persistent execution as well. Its runtime instances are designed for agents that run continuously for multiple days, share context, collaborate, and maintain persistent filesystems. Amazon Web Services, Inc.
Microsoft Foundry is doing the same. Hosted Agents provide dedicated per-session sandboxes, durable filesystem state, persistent context, integrated identity, and automatic recovery for long-running agents. Microsoft for Developers
These features are necessary because serious agents will not be single-shot jobs. They will investigate, wait, delegate, resume, escalate, remediate, verify, and remain available for the next turn.
But that same persistence makes static authority increasingly awkward.
Suppose an agent spends a day on an incident. It begins with read-only access to telemetry. Later, a human approves a narrow production change. The agent receives temporary write authority to three services. After remediation, that write authority should disappear while the agent continues monitoring.
The runtime session may stay alive the entire time. The authority should not. If the session itself is treated as the security object, operators eventually end up with one of two bad designs: either tear down and recreate the runtime every time authority changes, or give the session the union of everything it may need over its lifetime.
The first undermines the continuity these runtimes are being built to provide. The second creates a long-lived over-privileged agent. Neither is a good foundation for autonomous systems.
OpenShell shows why sandbox policy is still too coarse
NVIDIA OpenShell is one of the most serious attempts to move agent safety below the model. Its policy controls filesystem access, process identity, network destinations, and request behavior, with Landlock enforcing filesystem restrictions and network rules dynamically enforced while the sandbox runs. NVIDIA Docs
OpenShell also makes the current limitation unusually clear.
Filesystem, Landlock, and process settings are fixed when the sandbox starts. Network policy can change dynamically, but those kernel-level filesystem and process boundaries remain tied to sandbox creation. NVIDIA Docs
That is a reasonable sandbox model. It is not a sufficient authority model for long-running agents. One sandbox can host several objectives. One objective can change authority several times without the sandbox needing to disappear. A child objective may need less authority than its parent. A resumed workflow may need less authority than it had when the snapshot was taken.
The sandbox is a containment unit. The objective is the thing whose authority actually changes. Those are different lifecycles.
Intent Containers make the objective durable
This is why we think the durable object in agent infrastructure should be the objective itself.
An Intent Container is not another VM, container, or agent framework. It is the authority-bearing runtime object for the work being performed. It carries the objective identity, lineage, delegated authority, current authority epoch, revocations, and lifecycle state independently of whichever process, sandbox, or microVM happens to be executing it at the moment.
The underlying runtime can then become what infrastructure wants it to be: replaceable. A Google Agent Substrate sandbox can suspend and resume. A Bedrock AgentCore runtime can restart or migrate. A Microsoft Foundry session can recover after a failure. An OpenShell sandbox can be recreated on a different backend. The objective remains the source of truth through all of those events. When execution reappears, it binds to the current objective state. It does not inherit whatever authority happened to be frozen into the runtime image, process state, or snapshot.
Intent Containers can take more than one enforcement form
This is important because Intent Containers are an abstraction, not a commitment to one enforcement backend.
On Linux, one realization is Intent Containers + KAP.
KAP, the Kernel Assurance Plane, carries objective authority into kernel-visible intent groups. Processes, files, sockets, and system calls can then be constrained according to the current authority of the objective lineage executing them. That gives us the strongest possible binding between intent and actual effects.
But not every environment will allow or want a kernel modification.
In those deployments, the same Intent Container model can be enforced through Intent Containers + iVisor.
iVisor provides a portable interposition layer around the agent runtime and tool boundary. It can enforce the same objective-scoped authority without requiring a custom kernel, making the architecture usable in environments where the underlying OS is managed by a cloud provider or where kernel changes are operationally impractical.
The important property is not whether KAP or iVisor is underneath. The important property is that the authority comes from the objective and survives independently of the runtime. In one environment, that authority may reach all the way to the syscall boundary. In another, it may be enforced at process, tool, filesystem, or API interposition points. The backend can change. The authority model should not.
This is where the current runtimes remain insufficient
OpenShell, Agent Substrate, AgentCore, and Foundry are solving increasingly sophisticated execution problems.
They isolate agents. They persist state. They resume sessions. They scale agents down when idle. They recover from crashes. They broker identity and credentials. They maintain filesystems and context. Those are all important capabilities. They still do not make objective authority with an independent lifecycle a first-class runtime primitive.
That omission matters because execution continuity and authority continuity are not the same thing. A perfectly restored sandbox can still carry stale authority. A perfectly isolated runtime can still contain several objectives that should have different permissions. A perfectly authenticated agent can still be acting under the wrong stage of a workflow. A persistent session can preserve state long after the authority that justified that state has changed. The runtime can be healthy while the authorization model is stale.
That is the false comfort we need to avoid.
CVE-2026-80521 is useful because it reminds us the substrate is ordinary
The kernel bug itself will be patched. Another kernel bug will eventually replace it. That is normal. The same will be true for hypervisors, container runtimes, agent frameworks, checkpointing systems, and managed execution platforms.
Agent infrastructure should be designed with the assumption that those layers are temporary and fallible.
A process can die. A sandbox can be rebuilt. A microVM can be replaced. A snapshot can be restored. A runtime can migrate.
The objective may continue through every one of those events. The authority of that objective has to remain current through them too. That is why we think the industry is solving only half of the persistence problem.
The emerging runtimes are getting exceptionally good at preserving computation. Intent Containers are about preserving the meaning and authority of the work.
That can take different forms: Intent Containers with KAP where deep kernel enforcement is available, Intent Containers with iVisor where portability matters more, and additional backends as agent runtimes continue to evolve. The architectural rule stays the same:
The runtime is disposable. The objective is not.
We are building this in public at ArmorIQ, and there is a lot more coming around Intent Containers, intentd, KAP, iVisor, and how these pieces compose with the new generation of agent runtimes.



