NVIDIA donated OpenShell to the CNCF: what it secures, and what it leaves open when agents deploy to your own cloud
On 10 November 2026 NVIDIA contributed OpenShell, its open-source runtime for sandboxing AI agents, to the CNCF as a Sandbox project. Here is what OpenShell controls, what CNCF Sandbox status means, and the second layer you still need when an agent deploys to production in your own AWS, GCP or Azure account.
NVIDIA contributed OpenShell to the CNCF on 10 November 2026, at KubeCon + CloudNativeCon North America, as a Sandbox project. OpenShell is an Apache 2.0 runtime that runs AI agents (Claude Code, Codex, OpenCode, GitHub Copilot CLI and others) in a kernel-isolated sandbox governed by declarative policy. It is moving to a neutral ai-openshell GitHub organization and is adopting Cedar, another CNCF project, as its policy language.
CNCF Sandbox is the entry tier. The CNCF describes Sandbox projects as "experimental projects not yet widely tested in production". OpenShell is still on 0.1.x releases, so treat it as a strong building block, not a finished control.
OpenShell secures the agent's execution. It confines files, processes and syscalls, denies outbound connections by default, filters HTTP requests per binary, and keeps real credentials away from the agent.
It does not decide what the agent may change in production. Once a sandbox is allowed to reach your cloud API, Kubernetes API or deployment platform, the blast radius is whatever the injected credential can do. That second layer needs scoped credentials, a deployment policy, a human gate for production and an audit trail that names the agent.
Qovery is not an execution sandbox. It sits on the deployment side: agents call the Qovery API or MCP Server instead of holding a kubeconfig, API Policy Tokens are checked against an OPA policy on every request, and every action lands in an audit log. Apps run in your own AWS, GCP, Azure or Scaleway account, or your existing Kubernetes cluster.
Last Tuesday, NVIDIA handed OpenShell to the Cloud Native Computing Foundation. I think it is the most useful agent security news of the year, because it moves the boundary around an AI agent out of the agent's own prompt and into infrastructure that a platform team can inspect.
It also creates a comfortable illusion. I already hear "we sandbox our agents with OpenShell, so we're covered" in calls with platform teams. A sandbox answers "what can this process touch on the machine and on the network?". It does not answer "should this agent be allowed to roll out a new image to the production payments service at 3am?". Those are two different controls, and most teams I talk to have bought or built only one of them.
What did NVIDIA donate to the CNCF, and when?
NVIDIA contributed OpenShell to the CNCF as a Sandbox project on 10 November 2026, announced at KubeCon + CloudNativeCon North America. Both the CNCF announcement, co-signed by Jonathan Bryce of the CNCF and Ali Golshan of NVIDIA, and NVIDIA's own post are dated that day.
Here are the facts I could verify against primary sources:
What it is. NVIDIA's OpenShell documentation describes it as "an open-source runtime for executing fleets of autonomous AI agents in sandboxed environments with kernel-level isolation".
What it governs. In NVIDIA's words, OpenShell "applies deterministic controls to agent activity, so teams can enforce policies as agents use tools, access inference services and execute workloads" (NVIDIA).
Licence and home. Apache License 2.0 (OpenShell licence page). The CNCF says the project "is moving from NVIDIA's GitHub repository to a neutral organization, ai-openshell" (CNCF).
Who builds it. "Core contributors from NVIDIA, Red Hat, Docker, and Canonical have worked on the project since its inception" (CNCF).
Policy language. "OpenShell is adopting Cedar, another CNCF project, as its policy language" (CNCF). Cedar, the authorization language AWS created, itself entered the CNCF Sandbox in October 2025 (CNCF Cedar project page).
Adoption claims. NVIDIA says "hundreds of organizations have put OpenShell to use, and the project has received tens of thousands of contributions in less than a year since launch" (NVIDIA). That is the vendor's own number; I found no independent count.
The same announcement covered a second project. NVIDIA is contributing to Agent Substrate, a Google-originated CNCF Sandbox project for long-running agent workloads on Kubernetes, and NVIDIA says it is working with Google on an integration "so enterprises can secure and govern agents across clouds and on-premises systems" (NVIDIA). Google introduced Agent Substrate alongside its Agent Sandbox work on GKE.
What does CNCF Sandbox status mean for a team that wants to adopt OpenShell?
CNCF Sandbox status means neutral governance and an open roadmap, not production readiness. The CNCF describes Sandbox projects as "experimental projects not yet widely tested in production on the bleeding edge of technology" (CNCF Sandbox projects), and only Graduated projects are labelled "stable, widely adopted, and production ready".
Every CNCF project starts there, and Kubernetes-adjacent security tooling often reaches real production use long before graduation. It is a reminder to plan for change:
The release line is young. The project README describes a 0.1.x line with work planned on "new isolation primitives, an expanded extension surface, and new APIs" (OpenShell README). Expect breaking changes in policy and APIs.
The policy language is in transition. The current docs describe declarative YAML policy (OpenShell policies), while the CNCF post announces the move to Cedar. If you write a lot of policy today, keep it small and well tested so the migration stays cheap.
Kubernetes support is on the roadmap as well as in the product. The gateway already has a Kubernetes compute driver, and the CNCF post lists "broader support across Linux, macOS, and Kubernetes, security reviews, adversarial testing" as areas where it wants contributors.
What changes with the donation is control of the roadmap. A security boundary governed by a single vendor's product priorities is a hard sell to a regulated buyer. Under the CNCF, Red Hat, Docker, Canonical and anyone else can shape it, and the trademark sits with the foundation.
How does OpenShell sandbox an AI agent?
OpenShell runs each agent in an isolated sandbox provisioned by a gateway, confines files, processes and syscalls with kernel controls such as Landlock and seccomp, routes every outbound connection through a policy check, and injects credentials only into requests bound for approved endpoints. The agent never sees the real secret.
The architecture has three pieces in the README: a gateway, a supervisor and the sandbox. The gateway docs call the gateway "the control plane for OpenShell", responsible for provisioning sandboxes, managing credentials and enforcing policy. It provisions sandboxes through one of four compute drivers: Docker, Podman (rootless), Kubernetes ("pods in an operator-managed cluster") or MicroVM for VM-backed isolation.
Policy covers distinct domains, and the timing matters (OpenShell policies):
Policy domain
What OpenShell controls
When it can change
Filesystem
"Paths that sandbox processes can read, or read and write", enforced with Landlock
Fixed once the sandbox starts
Process
The user and group sandbox processes run as, plus syscall filtering with seccomp
Fixed once the sandbox starts
Landlock behaviour
Whether the sandbox refuses to start if filesystem rules cannot be applied
Fixed once the sandbox starts
Network
"Destinations each binary can reach, and the requests it can send", including HTTP-level rules such as read but not write
Can change while the sandbox runs
Credentials (providers)
Real secrets added only to requests sent to approved endpoints, with their own network rules
Attach, rotate and revoke at runtime
Three design choices stand out to me.
Egress is deny by default. "OpenShell denies every outbound connection from a sandbox unless a rule in network_policies allows it." Prompt-injection attacks on coding assistants usually end with data leaving over an outbound request the tool was allowed to make (Embrace The Red's GitHub Copilot Chat write-up is a good example), so this default does more than any other line of config.
Rules are per binary and per request. A policy can let git reach your Git host while blocking curl, and can allow GET on an API but not POST. That is much finer than a network policy on a pod.
Credentials are placeholders. The README says it plainly: "Agents never see real credentials; OpenShell adds them only to requests bound for approved endpoints." A prompt-injected agent cannot paste a token it never had into a GitHub issue.
There is also a formal verification step. Before a policy change is approved, OpenShell "uses formal verification to flag risky new access it would grant" (README). With Cedar, which was built to be analysable by automated reasoning, that check should get stronger.
If you already compared sandboxes with us, OpenShell sits in a different spot from the hosted ones. E2B, Daytona or Modal sell you isolated compute. AWS Nitro Sandboxes, launched on 9 November 2026, give each EKS pod a hardware-isolated microVM. OpenShell is a policy runtime you place around the agent, and it can use any of those isolation backends underneath. I covered the isolation side in AWS Nitro Sandboxes on EKS vs Daytona, E2B and Modal and the wider market in the best ephemeral code execution environments for AI agents.
What does OpenShell not cover when an agent deploys to your own cloud?
OpenShell decides whether the agent's process may reach an endpoint and send a given request. It has no model of your environments, services or release process, so once you allow the sandbox to call your cloud API, Kubernetes API or deployment platform, what the agent can change in production is decided by the credential you injected, not by OpenShell.
Take a realistic setup. A coding agent runs in an OpenShell sandbox. Egress allows your Git host, your model endpoint and the Kubernetes API of your EKS cluster. You attach a kubeconfig as a provider credential, so the agent never sees it. Good hygiene so far.
Now the agent misreads a ticket and runs kubectl scale deployment api --replicas=0 -n payments. OpenShell sees an HTTPS PATCH to an allowed host from an allowed binary, adds the credential and forwards it. The API server sees a valid request from the kubeconfig's identity and applies it. Every layer worked exactly as configured, and production is down.
You can push OpenShell's HTTP rules further, for example allow PATCH only on paths under /apis/apps/v1/namespaces/staging/. That works for a narrow case. It becomes painful fast, because the knowledge of what "staging" means, which services are critical, and who must approve a production rollout lives in your deployment system, not in URL patterns. Path rules also say nothing about the content of a request: an allowed PATCH can change the image to an untested tag.
Here is what stays outside the sandbox boundary:
Environment semantics. Production versus preview, which services are in scope, and which changes are reversible.
The scope of the credential. A cluster-admin kubeconfig or an AWS key with AdministratorAccess behind a perfect sandbox is still cluster-admin.
Approval. No human gate exists for production unless your pipeline or platform adds one.
Rollback. Undoing a bad change is a deployment feature, not a sandbox feature.
This is what OWASP calls excessive agency: "excessive functionality, excessive permissions, or excessive autonomy" granted to an LLM-based system (OWASP LLM06:2025). Sandboxing reduces what a compromised agent can steal. It does little about an agent that is wrong in good faith with valid permissions. And honest mistakes are common: Veracode's 2025 study found that 45% of AI-generated code samples introduced OWASP Top 10 vulnerabilities across more than 100 models (Veracode).
The MCP specification's own guidance points the same way. Its security best practices warn against token passthrough and recommend starting from minimal scopes. That advice is about the credential, which is the layer OpenShell intentionally leaves to you.
How do execution sandboxing and deployment governance compare?
Execution sandboxing protects the machine and network around the agent from the agent; deployment governance protects your running systems from what the agent asks to change. You need both, and they answer different questions, as this table shows.
Next to the agent runtime (OpenShell gateway, pod spec, VM)
In the deployment API or platform the agent calls
What it knows about production
Nothing beyond URL patterns you write
Which environment is production and which actions are allowed there
Credential handling
Hides the secret from the agent
Decides how much that secret can do
Human approval
Approves policy changes for the sandbox
Gates production deploys, merges or high-risk actions
Audit record
Sandbox and network decisions
Who (which agent, which human) changed what, where, and under which policy
Typical owner
Security or AI platform team
Platform or DevOps team
The two layers meet at the credential. OpenShell makes sure the agent cannot see or leak it. Deployment governance makes sure that even if the agent uses it badly, the damage is bounded.
Sandbox the agent. Govern what it ships.
Qovery lets AI agents deploy through a scoped, policy-checked and audited API to your own AWS, GCP, Azure or Scaleway account, or your existing Kubernetes cluster. Read-only by default.
No single open-source project covers both layers today. OpenShell and Kubernetes agent-sandbox cover execution, policy engines and GitOps cover parts of deployment, and an internal developer platform puts scoped credentials, deployment policy and audit behind one API. Here is how I would map the options I see most often.
Tool
Layer
What it controls
Runs in your cloud account
Maturity (November 2026)
NVIDIA OpenShell
Execution
Filesystem, process, syscalls, per-binary egress and HTTP rules, credential injection
Yes (Docker, Podman, Kubernetes or MicroVM driver)
CNCF Sandbox, 0.1.x
Kubernetes agent-sandbox / Agent Substrate
Execution and lifecycle
Isolated, stateful agent pods on Kubernetes; suspend and resume
Yes
Kubernetes SIG project / CNCF Sandbox
AWS Nitro Sandboxes on EKS
Execution (isolation backend)
Hardware-isolated microVM per pod, ECS task or EC2 workload
Yes, AWS only
Launched 9 November 2026
E2B, Daytona, Modal
Execution
Hosted isolated sandboxes for agent code
Mostly hosted by the vendor; some offer self-hosting
Generally available products
Kyverno, OPA Gatekeeper
Deployment (admission)
Allow or deny Kubernetes objects at admission time
If you have a platform team, OpenShell plus GitOps plus Kyverno plus a per-agent identity is a complete, fully open-source answer. It is also four systems to run, upgrade and keep consistent. That trade-off is the whole decision.
How should the two layers fit together for agents that deploy to AWS, GCP or Azure?
Put the agent in an execution sandbox with deny-by-default egress, let it reach only one deployment API, give it a credential scoped to non-production by policy, keep production behind a human gate, and make sure every action is attributed to that agent. Six steps, in this order.
Sandbox the session. Run the agent in OpenShell (or an equivalent) with filesystem write access limited to the workspace and egress denied by default.
Allow one deployment path. Open egress to your Git host, your model endpoint and one deployment API. Do not open the Kubernetes API or cloud control-plane APIs to the agent directly unless you have to.
Scope the credential by environment, not by URL. The token the sandbox injects should be allowed to deploy, redeploy or roll back preview and staging environments, and nothing else. Deletion and production should be denied by the policy attached to the token.
Gate production on a human. Production changes go through a pull request and a merge, or a platform approval, never directly from the agent session.
Give each agent its own identity. One token per agent (or per agent and human pair), named so the audit log reads like a sentence.
Give the agent a disposable target. A preview environment per pull request is where the agent can deploy freely, because deleting it costs nothing.
Steps 1 and 2 are OpenShell's job. Steps 3 to 6 belong to whatever the agent deploys through. If that is raw Kubernetes, our attribution and audit trail guide has the ServiceAccount, TokenRequest and audit policy recipe. If it is a platform, the platform has to provide scoped tokens and audit natively.
Keep the two policies owned by the same team, or at least reviewed together. A sandbox that allows api.example.com and a token that can delete every environment on api.example.com will each pass their own review.
Where does Qovery fit, and where doesn't it?
Qovery covers the deployment governance layer, not the execution sandbox. Agents call the Qovery API, CLI or MCP Server instead of holding a kubeconfig or cloud keys, each agent can get its own policy-scoped token, and every action is recorded in the Qovery audit log. Your apps keep running in your own cloud account or cluster.
To be precise about what Qovery is: an Agentic DevOps platform with a control plane run by Qovery and a data plane in your own AWS, GCP, Azure or Scaleway account, or on an existing Kubernetes cluster (BYOK docs). Qovery does not host your applications, and it does not isolate agent processes. If you need to run untrusted agent code, run it in OpenShell, Nitro Sandboxes or a hosted sandbox.
What Qovery adds on the deployment side:
API Policy Tokens (in Preview). A token carries no role; an OPA/Rego policy is evaluated on every request, based on the action, the resource, the HTTP method and the request body (API Policy Token docs). We wrote about the design in Full control over permissions, welcome API Policy Tokens. A typical agent policy allows redeploy and rollback on staging and denies everything else.
Attribution. Actions made with a policy token appear in the Qovery audit log as policy:<token-id>:<token-name>, so "agent-claude-code-romaric redeployed staging/api" is a real log line.
Read-only by default for agents. The Qovery MCP Server starts read-only; write access needs an explicit flag and write access enabled in the Console.
A disposable target. Preview environments per pull request and environment cloning give the agent somewhere safe to deploy.
Your account, your logs. The cluster, its native audit logs and the cloud bill stay with you.
The combination I recommend: OpenShell around the agent, with egress open to your Git host, your model provider and the Qovery API only, and a Qovery API Policy Token attached as an OpenShell provider credential. The agent never sees the token, the token can only touch what its Rego policy allows, and both layers leave a record. If you are weighing where your real backend should run once agents enter the picture, Alessandro's piece on Render Sandboxes versus a backend in your own cloud account covers that split.
What should a platform team do about OpenShell this quarter?
Pilot OpenShell on the agents your engineers already run locally, keep it out of the critical path until the Cedar migration and a 1.0 line land, and spend the bigger effort on credential scope and audit, which protect you whatever sandbox you end up with.
A short checklist:
Inventory every agent that can reach a cloud or cluster API, and the credential each one uses
Replace shared or human credentials with one scoped token per agent
Deny production writes to every agent token by policy; production goes through a human gate
Pilot OpenShell on Claude Code or Codex sessions with deny-by-default egress
Inject deployment credentials as OpenShell providers so agents never hold them
Ship sandbox decisions and deployment audit events to the same SIEM
Track the ai-openshell repository for the Cedar policy migration before writing large policy sets
How do I set this up with Qovery from Claude Code or Cursor?
Install the Qovery Agent Skills and, if you want, the Qovery MCP Server; your agent then deploys and troubleshoots through the Qovery API, attributed to your user or to a named token, instead of holding a kubeconfig. Four commands, all optional except the first.
curl -fsSL https://skill.qovery.com/install.sh | bash
# 2. Or for the current project only
curl -fsSL https://skill.qovery.com/install.sh | bash -s -- --project
# 3. MCP Server in Claude Code over OAuth, read-only by default
claude mcp add --transport http qovery https://mcp.qovery.com/mcp --callback-port 4242
# 4. Read/write, only when you explicitly want it
claude mcp add --transport http qovery "https://mcp.qovery.com/mcp?read_write=true" --callback-port 4242
Your agent asks you to approve each install command, and the MCP Server opens an OAuth login in your browser. Write mode also needs write access enabled in the Qovery Console. The skills deploy (qovery-onboard, qovery-deploy, qovery-troubleshoot, qovery-preview and others); the MCP Server operates what already exists. Then ask in plain language, for example "deploy this app to my AWS account with Qovery". If the agent runs inside OpenShell, add the Qovery API host to the sandbox's allowed egress. Start from the AI agent quickstart or the Claude Code integration.
Frequently asked questions
What did NVIDIA donate to the CNCF in November 2026?
NVIDIA contributed OpenShell, its open-source runtime for running AI agents in policy-governed sandboxes, to the CNCF as a Sandbox project on 10 November 2026 at KubeCon + CloudNativeCon North America. OpenShell is Apache 2.0, is moving to a neutral ai-openshell GitHub organization, and is adopting Cedar as its policy language. NVIDIA also announced contributions to Agent Substrate, a Google-originated CNCF Sandbox project for long-running agents on Kubernetes.
Is OpenShell production ready now that it is a CNCF project?
CNCF Sandbox is the foundation's entry tier for "experimental projects not yet widely tested in production", so the donation does not certify OpenShell as production ready. The project is on 0.1.x releases and its policy language is moving to Cedar. Pilot it on developer and CI agent sessions first, and plan for policy and API changes.
Does OpenShell secure AI agents that deploy to my own AWS, GCP or Azure account?
OpenShell secures the agent's execution: files, processes, syscalls, outbound connections and credential exposure. It does not know which of your environments is production or what a deployment is allowed to change, so once the sandbox can reach your cloud or deployment API, the injected credential decides the blast radius. Pair it with per-agent scoped credentials, a deployment policy, a human gate for production and an audit log that names the agent.
What is the difference between sandboxing an AI agent and governing what it deploys?
Sandboxing an AI agent limits what its process can touch on the machine and the network, which protects against exfiltration and escapes. Governing deployments limits what the agent can change in running systems, using scoped tokens, environment-aware policy, approvals and audit. A sandboxed agent with a cluster-admin credential is still able to delete production.
Is Qovery an alternative to OpenShell?
No. Qovery is an Agentic DevOps platform for deploying to your own cloud account or Kubernetes cluster, and it does not isolate agent processes. It complements OpenShell on the deployment side with API Policy Tokens evaluated against OPA policies on every request, RBAC, preview environments per pull request and an audit log that attributes actions to each token. Many teams will run the agent inside OpenShell and let it deploy only through Qovery.
Romaric founded Qovery to make Kubernetes accessible to every engineering team. He writes about platform strategy, developer experience, and the future of cloud infrastructure.
Next step
Sandbox the agent. Govern what it ships.
Qovery lets AI agents deploy through a scoped, policy-checked and audited API to your own AWS, GCP, Azure or Scaleway account, or your existing Kubernetes cluster. Read-only by default.