TL;DR
OpenShell (Apache-2.0, originally NVIDIA) joined the CNCF Sandbox on 2026-11-10 (CNCF post, reshared by NVIDIA AI; CNCF announcement). It is a runtime for fleets of autonomous agents that lets them read files, install packages, call APIs and use credentials without handing them the machine, the network or the secrets.
Two ideas carry it:
Enforcement below the agent. Every file access, system call and network connection is checked against a declared policy at the kernel and network layer, not by asking the model to behave.
Verified policy changes. When an agent asks for more access, an SMT-based prover checks what the change would newly allow (a new host with credentials, a new HTTP method, cloud metadata endpoints) and blocks auto-approval if it finds risky reach.
Architecture
Gateway. The control plane: identity, sandbox lifecycle, policy delivery, providers (stored credentials), and the policy prover.
Sandbox and supervisor. Each sandbox is split across a trust boundary. The sandbox side runs the agent as a child process, identifies the real calling program from
/proc, and intercepts TCP opens and DNS with seccomp user notification. The supervisor side is trusted and makes every decision. On Linux the workload runs as one non-root identity with no capabilities, and Landlock confines the filesystem.One egress path. An outer fence denies all network traffic except the channel to the supervisor (a Unix socket for Docker and Podman, TCP on Kubernetes, vsock for microVMs). The supervisor resolves DNS, checks the request, opens the real connection and relays it.
Credentials by placeholder. Agents never see real secrets. Providers map a service name to a stored credential, and the supervisor adds it only to requests bound for endpoints the policy allows.
Fail closed. The agent cannot start until the supervisor confirms the boundary, and it is frozen if the channel drops.
Traces without egress. Agent OpenTelemetry goes to a reserved address the supervisor answers itself, tags with the sandbox ID and forwards, so the agent never learns where the collector is.
Policy and the prover
Policies declare filesystem, process, network and REST-level access. The prover runs two different checks:
Boundary check (
openshell-prover check candidate.yaml --boundary boundary.yaml): does a policy allow anything beyond a maximum policy? Intended for agents too, for example a parent agent checking that a subagent's policy stays inside its own. If the candidate exceeds the boundary, the prover returns a counterexample.Proposal risk check: runs automatically when an agent proposes a new network rule through the policy advisor, and flags new credentialed reach, new methods or metadata access for human review.
Passing one does not imply passing the other. The prover covers filesystem, process identity, Landlock settings, network connections and REST requests; for rules it doesn't model (GraphQL, MCP) it reports that it cannot check rather than silently passing.
Tradeoffs and failure modes
Guarantees are only as wide as the model. The prover's results hold for what its formal model represents, and the project says that model is still being extended. MCP and GraphQL rules are outside it today.
Allowed is not safe. An agent with legitimate access to an approved API can still misuse it (delete the wrong records, leak data through an allowed endpoint). Sandboxing bounds the blast radius; it does not judge intent.
Approval fatigue. Human review of flagged proposals only works if the flags are rare and legible; a noisy advisor turns into rubber-stamping.
Platform maturity. Version 0.1.x, a repository moving from NVIDIA to a new organization under CNCF, Windows support experimental, and Kubernetes enforcement dependent on a CNI that actually implements
NetworkPolicy.Mediated network has a cost. Every connection and DNS lookup goes through the supervisor; latency-sensitive or very chatty workloads will feel it.
Telemetry on by default. Anonymous operational counts are collected unless disabled.
Implications
The direction is clear and worth adopting regardless of product: treat the agent as an untrusted process, enforce access below it, keep secrets out of its reach, and put a checker, not a model, in front of every widening of permissions.
Run agents with no direct egress; route every connection through a policy point
Never give agents real credentials; inject them per request at approved endpoints
Write a maximum (boundary) policy per environment and check every agent policy against it
Require human review for new credentialed destinations and new write methods
Fail closed when the enforcement channel is lost
Collect agent traces through the sandbox, tagged by sandbox, without opening egress
Related entries
R021 DeepSeek's Super-agent: an authority model for who may give an agent work; OpenShell is the runtime layer that bounds what that work can touch.
R020 The model proposes, the harness enforces: OpenShell moves enforcement down to the kernel and network.
R006 6 must-know terms for AI agent harnesses: permissions and sandboxing as harness concepts.
R028 auto-ontology-mcp: the same read-only, validate-before-execute posture applied to databases.
Sources
NVIDIA/OpenShell README and the architecture, policy prover and providers docs in its
docs/tree, main branch, 2026-11-10CNCF announcement, 2026-11-10
CNCF LinkedIn post and NVIDIA AI reshare, 2026-11-10