Your AI Agent Is Sandboxed. Have You Actually Tested the Boundaries? A developer stress-tested NVIDIA OpenShell, an agent sandbox for Kubernetes, and found that standard Linux checks like non-root UID, NoNewPrivs, and seccomp filter mode confirm hardening defaults but do not demonstrate the actual security boundary. The writeup maps OpenShell's layered controls — Landlock for filesystem access, seccomp user notification for intercepting network requests, a trusted supervisor for policy mediation, and Kubernetes NetworkPolicy — and argues each must be tested separately because the mechanisms are not interchangeable. What I learned examining NVIDIA OpenShell on Kubernetes, from seccomp and Landlock to network mediation, policy enforcement, and runtime security evidence. I recently started testing NVIDIA OpenShell because I wanted to understand something that isn't always obvious from agent security documentation: what actually stops an AI agent from doing something it shouldn't? I'd already spent time working with LLM gateways, guardrails, and observability. Those systems are useful for inspecting prompts, controlling model access, and understanding what applications send to an LLM. But once an agent can execute commands, access a filesystem, or call external services, prompt filtering is only part of the story. A perfectly ordinary user request might lead to several tool calls, process executions, and network connections. The model doesn't necessarily have malicious intent. It might simply choose an unexpected way to complete the task. So I wanted to examine the runtime boundary itself. I used OpenShell in a Kubernetes-based lab and began with some basic Linux security checks. The first results looked reassuring. They also turned out to be much less informative than I'd expected. My initial checks returned: uid=10001 NoNewPrivs: 1 Seccomp: 2 These are sensible defaults for an execution-capable workload. The process was running without root identity. The kernel reported NoNewPrivs , and seccomp was in filtering mode. But none of these values answers the question I was actually trying to investigate. Which operations can this agent perform, and where are those restrictions enforced? Consider each result separately. A non-root process generally has fewer privileges than a root process. That's useful, particularly when the workload may execute code selected by an LLM. But UID alone doesn't tell us which resources are accessible. A non-root process can still read files it has permission to access. It may also have network connectivity, application credentials, or writable directories. The security outcome depends on the full permission model, not just the numeric user ID. The no new privs setting prevents a process from gaining additional privileges through certain execution transitions. It's a valuable hardening mechanism. However, it doesn't revoke privileges the process already possesses. An agent doesn't need to escalate privileges to misuse an API credential that was intentionally made available to it. This indicates seccomp filter mode. It tells us that syscall filtering is active. It does not reveal the complete effective filter, which operations are restricted, or whether the controls correspond to the policy we intended to enforce. A process may be heavily restricted in one area and still have substantial permissions elsewhere. At that point, I'd established three useful environmental properties. I hadn't yet demonstrated the security boundary. Looking more closely at OpenShell's architecture changed how I thought about testing it. OpenShell separates the agent workload from a trusted supervisor. The agent runs on the untrusted side of the boundary. The supervisor handles policy decisions and mediates supported operations. On Linux, the design uses several mechanisms with different responsibilities: | Mechanism | Responsibility | |---|---| | Non-root identity and capability restrictions | Reduce process privileges | | Landlock | Restrict filesystem access | | Seccomp and user notification | Intercept relevant operations, including network requests | | Trusted supervisor | Evaluate and mediate permitted connections | | Kubernetes NetworkPolicy | Restrict direct workload network connectivity | | Sandbox policy | Define permitted resources and operations | The important point is that these controls are not interchangeable. A filesystem restriction cannot replace an API authorization check. A NetworkPolicy object cannot tell us whether a user is allowed to modify a business record. A semantic guardrail cannot guarantee that a process will be unable to reach an unauthorized destination. Different boundaries require different enforcement mechanisms. In the documented OpenShell architecture, outbound TCP and DNS operations are mediated through the sandbox and trusted supervisor. Conceptually, the flow looks like this: AI Agent | | Requests a network connection v Sandbox Runtime | | Intercepts relevant operation | Identifies requesting executable v Authenticated Supervisor Channel | v Trusted Supervisor | | Evaluates effective policy | +---- DENY --- Connection rejected | +---- ALLOW -- Supervisor connects | v Approved Service This is a useful design because the workload doesn't make its own authorization decisions. The supervisor evaluates the operation outside the untrusted agent environment. But another component is equally important: the outer network boundary. If the workload could establish direct network connections without mediation, the supervisor wouldn't necessarily see those requests. On Kubernetes, OpenShell relies on NetworkPolicy enforcement to constrain that communication path. That means the cluster networking layer becomes part of the security argument. This is something worth emphasizing when evaluating sandbox environments on Kubernetes. You can inspect NetworkPolicy resources using: kubectl get networkpolicy -A You can also review the policies in the sandbox namespace: kubectl describe networkpolicy -n