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 <namespace>
These commands tell us what network restrictions have been declared.
They do not independently prove that the restrictions are working.
Kubernetes NetworkPolicy enforcement depends on a compatible network plugin.
In fact, the Kubernetes documentation makes an important distinction: the API stores the policy, but enforcement depends on the cluster networking implementation.
The OpenShell security documentation explicitly requires Kubernetes operators to use a CNI that enforces the relevant ingress and egress policies.
For me, this creates two separate validation questions.
First: Does the policy permit only the intended supervisor communication?
Second: Does the cluster actually enforce that restriction?
An effective assessment would need positive and negative connectivity tests in an isolated lab.
A permitted connection should work.
A prohibited connection should fail.
And the results should be correlated with the relevant policy and enforcement logs.
Checking only the Kubernetes resource isn't sufficient.
Another interesting part of OpenShell is its network policy model.
It's not simply a destination allowlist.
Rules can associate approved destinations with specific executables.
For example, allowing a command-line HTTP client to reach one service doesn't necessarily mean every executable in the sandbox should have the same permission.
That distinction matters because agents frequently launch other processes.
A Python-based agent might invoke a helper script, which invokes another program, which eventually establishes a network connection.
The executable actually opening the connection may not be the same path that appears in the original tool call.
OpenShell accounts for executable identity when evaluating the network policy.
This introduces an important testing requirement.
It's not enough to know that a destination is allowed.
You need to verify which executable is allowed to reach it, and whether broad matching rules unintentionally expand that permission.
For example, a rule intended to allow one trusted client may become much less restrictive if it matches almost any executable.
This is the type of configuration issue that can be missed during a quick functional test.
The agent completes its task successfully, so the system appears healthy.
But successful task completion says very little about whether least privilege has been maintained.
I also found the distinction between base policy and effective policy important.
A sandbox starts with a defined policy, but attached providers can contribute additional network permissions.
The effective policy reflects the permissions the runtime actually enforces.
That's what an assessor should examine.
Suppose an agent initially has access to one internal API.
Later, a provider is attached to support another service.
If that provider contributes network rules, the agent's reachable destinations may change even though the original base policy remains the same.
Nothing necessarily went wrong.
The change may be completely intentional.
But an assessment based only on the original policy would now be incomplete.
For repeatable testing, I would record:
I would also distinguish controls established at startup from those that can be updated dynamically.
That matters for regression testing.
A security test performed before a policy update may no longer describe the environment after that update.
During my experiments, I encountered a few operational issues.
One sandbox returned:
sandbox 'attt-test-01' is not ready
(phase: Completed)
When I attempted to create another sandbox using the same name, OpenShell reported that the name was already in use.
Later, another operation failed because the underlying pod was in a failed state.
These errors were frustrating, but I wouldn't classify them as security findings.
They were sandbox lifecycle issues.
Still, they revealed a practical weakness in my test process: I hadn't established a reliable way to recreate the exact environment for each experiment.
If a test doesn't run because the sandbox has completed, that isn't a security pass or failure.
It's an incomplete test.
That distinction sounds trivial, but it's easy to lose when reviewing a collection of terminal logs.
I also observed a runtime security alert involving the execution of a newly introduced binary in a container.
Again, this wasn't evidence of a sandbox escape.
An agent that executes code may legitimately create or invoke new binaries.
The useful question is whether the execution violated a defined policy.
To answer that, I'd need more than the alert title.
I'd want the executable path, parent process, sandbox identity, policy context, agent task, and corresponding runtime activity.
Without that information, I can say the event deserves investigation.
I can't say the isolation boundary failed.
After reviewing the architecture and my own incomplete results, I started organizing the assessment around security properties rather than individual commands.
Here's the matrix I'd use for the next controlled test cycle.
| Test | Expected property | Required evidence |
|---|---|---|
| Process identity | Agent operates with intended privileges | UID, capabilities and process security state |
| Filesystem read | Restricted resources cannot be read | Effective policy and observed denial |
| Filesystem write | Unapproved locations cannot be modified | Effective policy and operation result |
| Approved network access | Required destination remains reachable | Successful request and matching authorization |
| Unapproved network access | Connection is denied | Failed request and enforcement evidence |
| Executable identity | Network access is restricted to permitted executables | Executable identity and policy decision |
| Supervisor interruption | Agent does not continue unrestricted when mediation is unavailable | Runtime state transitions and logs |
| Tool authorization | User and workflow permissions are enforced | Application authorization decision |
| Observability | Agent action can be correlated with runtime activity | Trace ID, process and policy events |
The purpose isn't to produce the largest possible test suite.
It's to establish a defensible relationship between policy and observed behavior.
For each test, I would classify the result as:
Verified: The test ran successfully and the observed behavior matched the intended restriction.
Failed: The test completed, but behavior differed from the intended policy.
Not verified: The environment, evidence, or test execution was insufficient to draw a conclusion.
I particularly like keeping not verified separate.
An incomplete test should not turn into a successful security assessment just because no violation was observed.
There's another security boundary worth discussing.
Imagine an investigation agent operating in a properly configured sandbox.
The agent is allowed to reach an internal incident management API.
It can retrieve incident records and submit updates through that service.
Now suppose the agent attempts to modify a record belonging to another department.
The network connection might be completely legitimate.
The sandbox might be doing exactly what it was configured to do.
But the operation could still be unauthorized.
The sandbox controls access to execution resources and network destinations.
The application must independently determine whether the requesting identity is allowed to perform a particular operation on a particular resource.
This is why I think tool authorization needs to be part of the agent architecture rather than being treated as a prompt instruction.
A model can be told not to modify certain records.
That instruction may help guide its behavior.
But the API should still reject unauthorized modifications, even if the model attempts them.
The distinction becomes more significant with multi-agent workflows.
One agent might collect evidence. Another might summarize it. A third might propose a response action.
Even when each tool is individually permitted, transferring information or authority between them may create new risks.
Runtime isolation helps constrain what the execution environment can do.
It doesn't replace the application's responsibility to enforce identity, permissions, and data access.
This is the next area I want to explore more seriously.
At the LLM layer, platforms such as Langfuse can show model calls, retrieval operations, tool invocations, and workflow context.
At the runtime layer, process monitoring and Kubernetes telemetry can reveal actual execution events.
OpenShell's supervisor and policy logs add another perspective.
Ideally, those events should be correlated.
Consider a hypothetical event sequence:
Agent task received
|
v
Document retrieved
|
v
Agent selects a tool
|
v
Tool starts a process
|
v
Process requests network access
|
v
Supervisor evaluates policy
|
v
ALLOW / DENY decision
|
v
Result returned to agent
If we only log the model response, we may miss the execution decision.
If we only capture the kernel event, we may not understand why the process ran.
If we only collect policy decisions, we may not know which user request triggered them.
For meaningful security investigations, these views need to be connected.
I would start with a small set of correlation fields:
session_id
agent_id
tool_call_id
sandbox_id
policy_revision
process_identity
operation
decision
timestamp
These are proposed telemetry fields, not a claim that OpenShell and Langfuse automatically produce this exact schema.
Some would need to be propagated by the application or correlation pipeline.
I'd also be careful about logging sensitive data. Agent traces can contain prompts, retrieved documents, tool arguments, and credentials.
Better visibility shouldn't create a new data exposure problem.
Before this experiment, I tended to start with the familiar container security checks.
Is the process non-root?
Is privilege escalation disabled?
Is seccomp active?
Those checks are still useful.
I haven't stopped caring about them.
But for AI agent sandboxes, I'd now begin with a different set of questions.
Where is the trust boundary?
Which component makes authorization decisions?
Which operations are mediated?
What prevents the agent from using an unmediated path?
What does the effective policy allow?
And what evidence would convince me that the boundary works?
These questions are more demanding than checking three Linux security flags.
They're also closer to the real security problem.
I haven't finished validating every OpenShell boundary in my lab.
I verified some process-level hardening properties, reviewed how the architecture is intended to enforce restrictions, and encountered several operational issues that interrupted the test cycle.
I also observed runtime activity worth investigating, but nothing I collected was sufficient to establish a sandbox escape.
That's the honest scope of the experiment.
I still think OpenShell is a useful direction for securing execution-capable agents because it moves important enforcement decisions outside the language model.
But I wouldn't judge any agent sandbox by its architecture diagram alone.
The same applies to seccomp, Landlock, Kubernetes NetworkPolicy, and application authorization.
A declared control is not the same thing as an effective control. And an effective control is not the same thing as a control you've actually verified.
For AI agents, that distinction is going to matter more as we give them access to more systems and more consequential actions.
I'm interested in how other engineers are testing these boundaries, particularly around dynamic network permissions, multi-agent tool access, and runtime event correlation.
What would you consider sufficient evidence that an AI agent sandbox is enforcing its intended security policy?