NVIDIA donated OpenShell to the CNCF Sandbox on November 10 at KubeCon in Salt Lake City — making it the first open-source, zero-trust runtime purpose-built for governing autonomous AI agents. The timing lands with intent: prompt injection is the number one AI security threat in 2026, up 340% year-over-year, and 88% of organizations have already reported an AI agent security incident. The dominant defense — writing better prompts — is not actually a defense. It’s a prayer.
The Flaw in How We’ve Been Thinking About Agent Security #
When an agent is compromised via prompt injection, it doesn’t break your firewall. It uses your firewall. It calls the same APIs your policy allows, makes the same outbound connections your agent would normally make, and passes credentials your code handed it. Application-layer guardrails and carefully worded system prompts can’t stop this because they live inside the agent’s trust domain — the same space an attacker now controls.
OpenShell’s premise is that you need enforcement outside the agent process. Its policy enforcement runs at the kernel level via Landlock LSM, intercepting system calls independently of the container layer. A prompt-injected agent, a jailbroken model, a buggy tool — none of them can access what the policy denies. The agent physically cannot reach what isn’t listed. That’s not a constraint enforced by the LLM. It’s a constraint enforced by the kernel.
Four Components, One Boundary #
OpenShell’s architecture splits into four pieces that work as a single enforcement boundary:
Gateway is the control plane. It manages sandbox lifecycles, delivers policies, and runs the Policy Prover — a formal verification layer that checks agent-proposed network rules before anything gets approved.
Supervisor sits on the trusted side, completely separated from the sandbox workload. It makes policy decisions, resolves DNS, and brokers credentials. The sandbox never decides anything on its own — it reports intent and waits.
Sandbox is where the agent runs. It can only communicate with the Supervisor through a single secured channel. That’s the only exit.
Policy Prover does formal verification on proposed network rules. It ships as a standalone openshell-prover CLI so you can run policy checks in CI before an agent touches production.
Agents Never See Your Credentials — That’s the Point #
This is the most underappreciated part of OpenShell’s design. Rather than handing credentials to the agent and hoping it doesn’t leak them, OpenShell uses a provider profile model: service names map to stored credentials that live in the Supervisor, not in the sandbox. The Supervisor injects credentials only into requests bound for explicitly approved endpoints. If an agent tries to exfiltrate your API key to an attacker-controlled server, the connection is blocked before it’s made — not because the model was told not to, but because the endpoint isn’t in the policy.
This design directly addresses the attack pattern that compromised GitHub Actions environments in 2026 through hijacked Copilot Agent sessions, and the Hugging Face intrusion in July that chained credential theft across agent boundaries.
Policy as Code #
Everything is declared in YAML — filesystem paths, network endpoints, process identity. Nothing is permitted by default:
filesystem_policy:
read_only: [/usr, /etc]
read_write: [/workspace/project]
network_policies:
- binary: python3
allowed_endpoints: [https://inference.local]
process:
user: agentuser
The openshell-prover check command lets you validate policy against a production boundary in CI before deployment — shift-left agent security without instrumenting the model. Supported agents include Claude Code, Codex, GitHub Copilot CLI, and LangChain Deep Agents. Supported compute: Docker, Podman, Kubernetes via Helm.
Why CNCF, and Why Now #
NVIDIA could have kept OpenShell proprietary or released it under a permissive license and walked away. Donating it to the CNCF means something specific: no single vendor controls its direction. The project follows a public RFC process and vendor-neutral governance model — the same framework that governs Kubernetes and Prometheus.
At the same KubeCon, Google donated Agent Substrate and gVisor to CNCF. NVIDIA is actively integrating OpenShell with Agent Substrate for cross-cloud and on-premises agent governance. This is the beginning of a CNCF-native stack for agentic AI — not a product ecosystem, but infrastructure commons.
Try It #
pip install openshell-runtime
openshell run --policy ./my-policy.yaml -- claude-code "fix the bug in app.py"
openshell-prover check --policy ./my-policy.yaml --boundary production
The documentation is at docs.nvidia.com/openshell, and the source is on GitHub under Apache-2.0.
The more uncomfortable question is what it says that this runtime needed to exist. If your production AI agents are currently running without policy-enforced boundaries, you’ve been relying on the model to protect your infrastructure. That’s the same as relying on an employee to never be phished. It’s not a security model — it’s optimism.