Trust and data disclosure
What the DevZero control plane can do inside your cluster, what caps it, what it can never do, and exactly which data leaves the cluster.
Trust and data disclosure
DevZero's control plane configures sandboxes in your cluster. That gives it real reach, and you should know how much before you enable the feature. This page lists it without softening.
How configuration reaches your cluster
DevZero never connects into your cluster. The DevZero workload operator already running there keeps an outbound connection to DevZero. Sandbox configuration travels down that connection as Kubernetes objects in the sandbox.devzero.io API group (policies, guardrails, the endpoint configuration, sandbox requests, token keys). The workload operator applies them; the sandbox operator turns them into pods, network policies and RBAC. Status travels back up the same connection.
To create a sandbox for an API caller, DevZero sends a sandbox request. The sandbox operator in your cluster, not DevZero, creates the sandbox claim from it. Sandbox output, files and terminal traffic never travel over this connection.
Guardrails cap mistakes, not DevZero
SandboxClusterGuardrails is a cluster-wide ceiling over every sandbox policy: which registries, runtimes, namespaces, Secrets, service accounts, resources and lifetimes any policy may use. A team Admin sets it in DevZero, and DevZero applies it to the cluster the same way it applies policies.
Because DevZero delivers the guardrails as well as the policies, guardrails protect you from a mistaken policy, not from DevZero itself. A compromised or coerced DevZero control plane could widen the guardrails along with a policy. The rows marked holds against DevZero below are enforced by code, RBAC or objects in your cluster that DevZero cannot change, and do not depend on guardrails.
If someone edits the guardrails object directly in the cluster, the sandbox operator enforces the edited version until DevZero's next push overwrites it.
What the control plane can do in your cluster
| The DevZero control plane can… | Through | Capped by |
|---|---|---|
| run any image in a sandbox namespace on the sandbox runtime | the policy's image settings | the guardrails registry list (allowedRegistries); the pod admission webhook re-checks every container |
give users, groups or service accounts admin rights (connect, delete, pods/exec) over a policy's sandboxes | the policy's access.adminSubjects, rendered as an admin Role | the guardrails list access.allowedAdminSubjects (an explicit list; empty means none). Groups such as system:authenticated, system:unauthenticated, system:serviceaccounts and system:masters are always refused. Holds against DevZero. |
| expose a Secret in a sandbox namespace to sandboxes | the policy's envFrom | the guardrails Secret selector, and the Secret must carry your annotation sandbox.devzero.io/exposable-to naming the policy. Neither DevZero operator can write that annotation. Holds against DevZero. No other Secret can be mounted. |
| let sandboxes reach Services in your cluster | the policy's network.egress.allowClusterServices | the guardrails list allowedClusterServiceNamespaces |
| let in-cluster service accounts create and connect to sandboxes | the policy's access.serviceAccounts, rendered as RoleBindings | the guardrails list access.allowedServiceAccountNamespaces |
| choose which namespaces hold sandboxes | the policy's namespace | the guardrails list managedNamespaces (exact names by default). An existing namespace is adopted only if you labelled it sandbox.devzero.io/managed=true and it holds no pods other than sandboxes. Holds against DevZero. |
| choose the runtime | the policy's runtime | the guardrails list allowedRuntimeClasses. The RuntimeClass's handler must be runsc (gVisor) or kata*. The one exception is a class your guardrails name exactly: naming a plain runc class there lets a policy use it, which removes the sandbox boundary, so name only sandboxing classes. |
| set resource ceilings and lifetimes | the policy's resources and lifecycle | the guardrails maxResources and maxTTL |
| route sandbox traffic through DevZero's edge | the endpoint configuration (mode: relay, Phase 3) | the guardrail endpoint.allowRelay (off by default). Even then the edge forwards encrypted bytes and cannot read them. |
| hold the TLS private key for your sandbox endpoint | none | Never. The key is generated in your cluster in every mode; at most a certificate signing request goes to DevZero. Holds against DevZero. The guardrail endpoint.allowPublicVisibility caps exposure. |
| issue tokens the sandbox gateway accepts | the public token-signing keys (a signed key set) it sends to the cluster | these keys are for the gateway only. The credential the gateway uses to reach each sandbox process is derived per pod and never leaves the cluster. |
| create and delete sandboxes | sandbox requests (the sandbox operator creates the claim) | the policy's limits.maxSandboxes, any quota, and the NetworkPolicy canary |
| read sandbox output or files | none | Never. The connection to DevZero carries only sandbox.devzero.io objects down and their status up. No DevZero component is in the data path except as an encrypted passthrough in relay mode. |
What the control plane cannot do, even if compromised
- create pods outside sandbox namespaces;
- adopt an existing namespace you have not labelled
sandbox.devzero.io/managed=true; - expose a Secret you have not annotated
sandbox.devzero.io/exposable-tofor that policy; - give
system:*-style groups admin rights over sandboxes; - write anything outside the
sandbox.devzero.ioAPI group, or anything inside a sandbox namespace, through the workload operator; - obtain the private key of your sandbox endpoint;
- decrypt sandbox traffic.
It can change the guardrails, and with them widen the registry list, turn on relay, and raise the other ceilings.
What leaves the cluster
This table replaces any slogan you may have read about sandbox data. "Managed" and "relay" are the Phase 2 and Phase 3 endpoint modes; Phase 1 ships "BYO". See Exposure modes.
| Category | Managed and BYO endpoints | Relay |
|---|---|---|
| Sandbox bytes (stdout, files, ports) | never | transit DevZero's edge encrypted end to end (TLS passthrough); never stored, never decrypted |
| Metadata sent to the control plane | sandbox and claim phases and reasons, pod IP, image reference, environment variable names, byte counts, team and user IDs, a keyed hash of each command line (or the command line itself if you turn on audit.recordCommands) | same |
| Keys | none. The endpoint private key is generated in your cluster in every mode (managed mode sends only a certificate signing request); in managed mode DevZero controls only the DNS name | none (the edge holds no certificate for your cluster) |
| DNS | managed: the load balancer address (possibly a private address) is published in public DNS | same |
Environment variable values, Secret contents, file contents and process output are not sent.
Availability
Running sandboxes and sessions continue until their
shutdownTimewithout DevZero; new external sandboxes, extensions, and tokens need DevZero; in-cluster creation does not.
Images
What a sandbox image needs, which DevZero base images exist, how registry allowlists and guardrails work, cloud registry auth, mirroring the sandboxd injector, and why an image override is a cold start.
How DevZero sandboxes compare
An honest comparison of DevZero self-hosted sandboxes with E2B BYOC, Modal, Docker Sandboxes and upstream agent-sandbox on its own.