Docker AI Governance and Sandboxes: What the Box Covers, and What Runs Outside It
- On November 19, 2026 Docker relaunched its brand around AI agents with the line "Run on trust", arguing that agents are actors, not workloads, and naming three new products: Docker Sandboxes, Docker AI Governance and the MCP Enterprise Gateway.
- Docker Sandboxes run a coding agent in a microVM with its own kernel, driven by the
sbxCLI. Local use is free, including commercially. Network egress is deny-by-default through a host proxy, and credentials are injected by that proxy so raw values never enter the VM. - Docker AI Governance is the paid central layer: network rules down to HTTP method and path, filesystem mount rules, Cedar policies for MCP tool calls through Docker's gateway, and audit records streamed to Splunk, Datadog or Grafana. Policy reaches developers when they sign in, through SAML and SCIM.
- Docker's own security notes list what the box does not cover: a direct workspace mount is read-write, so git hooks and
package.jsonscripts the agent writes land on the host; local stdio MCP servers run on the host with host permissions; remote MCP servers sit outside; and the default network allowlist is broad. - The structural limit is the one every sandbox has: it governs the sessions that start inside it. An agent launched from a plain terminal, an MCP server configured directly in an agent's settings, or a personal AI account in the browser never touches the boundary.
- Docker sells isolation. The question it leaves to you is coverage: which agents on which machines actually run inside the sandbox, and which run bare on the host.
Docker relaunched itself on November 19 around a single claim: AI agents are actors, not workloads. Containers isolate workloads; agents decide what to do, so they need products built to isolate and govern them. The new brand line is "Run on trust", and it arrives with three new products: Docker Sandboxes, Docker AI Governance, and an MCP Enterprise Gateway.
This is a significant signal for the category. One of the most widely deployed pieces of developer infrastructure has rebuilt its story around agent security. It is also a real technical boundary, not a marketing one, with credential handling that is better than most sandboxes we have looked at. This post covers what Docker built, the limits Docker itself documents, and the coverage question a sandbox cannot answer about itself. For how other vendors approach the same boundary, see our guides to NVIDIA OpenShell and the OpenAI Codex sandbox and approval model.
What Docker shipped
Docker Sandboxes run AI coding agents in isolated environments, either on the developer's machine or on Docker-managed cloud infrastructure, both created through the sbx CLI. Per Docker's documentation, the sbx CLI and local sandbox compute are free, including for commercial work; cloud compute is pay-as-you-go, and model charges are separate. The product page shows Claude Code, Kiro, OpenAI Codex, Cursor and Gemini CLI as supported tools.
Docker AI Governance is the central, separately paid layer that lets organisation admins manage sandbox network, filesystem and MCP policy across developer machines. The MCP Enterprise Gateway is the managed path for connecting and controlling MCP tools. Docker also positions Docker Hardened Images as the supply-chain half of the same trust story.
How the sandbox boundary works
The design choices are worth reading closely, because several of them are good ones:
- A microVM per sandbox, with its own kernel. Docker calls the VM boundary the primary trust boundary: the agent cannot reach anything on the host except what is explicitly shared. Inside the VM the agent has full control, including sudo.
- Deny-by-default egress. Outbound TCP goes through a host-side proxy and only allowed destinations are reachable. UDP is blocked unless an experimental feature is turned on, and ICMP is always blocked.
- Credentials stay outside the VM. The host proxy injects credentials into outbound HTTP headers, and Docker states that the raw credential values never enter the VM. A prompt-injected agent that dumps its environment finds nothing to exfiltrate. This is the most important control in the product, and it addresses the exact chain behind most agent credential theft.
- MCP through a host-side gateway. MCP traffic from the sandbox is routed through Docker's gateway, which is where MCP policy is enforced.
- Workspace modes. A direct mount gives the agent read-write access to your working tree; clone mode mounts the repository read-only and lets the agent work on a private clone; a mountless sandbox shares nothing.
What Docker AI Governance adds
Governance turns those per-machine settings into organisation policy. According to Docker, its three parts are:
- Sandbox policies. Allow and deny rules for domains, IPs and CIDR ranges, down to HTTP method, path and query, plus filesystem rules that control which host paths can be mounted and whether read-only or read-write. A developer can check the effective boundary before starting an agent with
sbx policy check, and the answer comes from the active policy, not from an instruction the agent is expected to follow. - MCP tool governance. Written in Cedar. When enforcement is active, governed requests are denied unless a policy permits them, unapproved servers are blocked by default, and specific tool calls can require confirmation.
- Audit and visibility. Structured records of policy decisions and sandbox sessions - principal, action, target, decision, time - containing governance metadata rather than prompts or responses. Records can stay local or go to Docker's cloud and be streamed to Splunk, Datadog or Grafana.
Policy is set centrally and reaches developers when they authenticate, scaled through the organisation's existing SAML and SCIM identity provider, so there is no per-machine configuration to drift.
$ sbx policy check network api.anthropic.com
Allowed: api.anthropic.com
$ sbx policy check network blocked.example.com
Denied: blocked.example.com
The limits Docker documents itself
Docker's security documentation is unusually candid about what the sandbox does not protect, and every item is worth a line in your rollout plan:
- Direct mounts write to the host immediately. That includes files that run implicitly later - git hooks inside
.git/(whichgit diffdoes not show), CI configuration, aMakefile,package.jsonscripts. The agent is contained; the code it leaves behind is not. This is the same class of issue as the git-hook sandbox escapes we covered in Cursor's CVE-2026-26268. Clone mode avoids it. - Local stdio MCP servers run on the host with host permissions, not inside sandbox isolation. Docker says to treat them as trusted host integrations.
- Remote MCP servers run outside Docker Sandboxes. If an agent connects to one directly from inside a sandbox, Docker notes that the connection falls under the sandbox network policy rather than MCP policy.
- The default network allowlist is broad, including wildcards such as
*.googleapis.comthat cover far more than AI services. Review it withsbx policy lsand remove what you do not need. - Shared skill stores mounted read-write put every participating sandbox in the same trust boundary.
- MCP tool annotations such as
readOnlyare supplied by the server and advisory. A Cedar rule that permits read-only tools trusts the server to describe itself honestly.
The coverage question a sandbox cannot answer
Every one of those limits is manageable. The structural one is not specific to Docker: a sandbox governs the sessions that start inside it. Docker AI Governance records sandbox policy decisions and sandbox session events. A developer who runs claude or codex from a plain terminal, an MCP server added directly to ~/.claude.json, an IDE extension calling a model with a personal key, or a personal ChatGPT account in the browser never touches the boundary, and so never appears in its audit stream.
That is not a criticism of the product; it is what isolation means. We saw the same pattern in survey data in the containment gap: organisations that built strong controls for the agents they enrolled still had no view of the ones they did not. A sandbox answers "is this session contained?" It cannot answer "what fraction of agent sessions on this fleet are inside a sandbox at all?", and that number is what decides whether the boundary is protecting you.
| Question | Docker AI Governance | Fleet inventory |
|---|---|---|
| Is this agent session isolated? | Yes, for sessions in a sandbox | No - it observes, it does not isolate |
| Which MCP servers may sandboxed agents call? | Yes, through the gateway | Shows the MCP servers configured on the host |
| Which agents are installed and configured on the host? | Not visible | Yes |
| Which AI web services and accounts are in use? | Not in scope | Yes, through the browser |
| Where do long-lived AI keys sit on laptops? | Not in scope; sandboxed sessions get proxy-injected credentials | Yes, redacted on the endpoint |
A rollout checklist
- Prefer clone mode or mountless sandboxes for agents doing anything autonomous, and review hooks, CI files and scripts after any direct-mount session.
- Trim the default network allowlist to the model endpoints and package registries each team needs.
- Treat local stdio MCP servers as host software. Approve them as you would any binary that runs with the developer's permissions.
- Write Cedar policies against servers you trust, not only against
readOnlyannotations a server supplies about itself. - Stream Docker's audit records to the SIEM next to your other agent telemetry, so a denied call can be correlated with what else happened on that machine.
- Measure coverage. Know which agents are installed on each machine and which teams actually launch them through
sbx. A sandbox that one team in five uses is a pilot, not a control.
How Anomity fits with Docker
Anomity complements a sandbox; it does not replace one. The Endpoint Sensor inventories the AI agents, MCP servers, extensions, plugins, skills, hooks, CLIs and local LLM runtimes configured on every managed machine, including Docker's own MCP Toolkit profiles, and finds secrets in AI tool configs, redacted on the endpoint. That is the host-side view of what exists, whatever does or does not start in a sandbox: the agent configured on the laptop, the stdio MCP server running with the developer's permissions, the key left in a shell profile.
The Browser Sensor covers AI web services, corporate versus personal sign-ins, secrets pasted or typed into prompts and file uploads, and cloud discovery covers GitHub and Google Workspace OAuth grants held by AI applications. At the agent hook, Anomity can allow, deny or log a tool call before it runs, for agents running directly on the host. Findings route to your SIEM, Slack, email or Jira alongside Docker's audit stream.
Docker is right that agents need a trusted runtime. The question to answer next is which of your agents are running in it. To see that across your fleet, book a 30-minute demo.
OpenCode shipped the credential-side version of the same idea this week: keyless OIDC auth for model calls from CI. We break down what it fixes in OpenCode Console goes keyless.
Frequently asked questions
What did Docker announce on November 19, 2026?
Docker relaunched its brand around AI agents with the line "Run on trust" and the argument that agents are actors rather than workloads. It named three new products: Docker Sandboxes for isolating coding agents, Docker AI Governance for central sandbox and MCP policy, and the MCP Enterprise Gateway for connecting and managing MCP tools.
How do Docker Sandboxes isolate an AI coding agent?
Each sandbox is a microVM with its own kernel, created with the sbx CLI. The agent can reach nothing on the host except what is explicitly shared, outbound network traffic goes through a deny-by-default host proxy, and that proxy injects credentials into outbound requests so raw credential values never enter the VM.
Is Docker Sandboxes free?
Per Docker's documentation, the sbx CLI and local sandbox compute are free, including for commercial work. Cloud sandboxes are pay-as-you-go, model-provider charges are separate, and central governance through Docker AI Governance requires a separate paid subscription.
What does Docker AI Governance control?
Sandbox network rules for domains, IPs and CIDR ranges down to HTTP method, path and query; filesystem mount rules with read-only or read-write scope; Cedar policies for MCP tool calls through Docker's gateway, with unapproved servers blocked by default; and structured audit records that can be streamed to Splunk, Datadog or Grafana. Policy reaches developers when they authenticate, through SAML and SCIM.
What do Docker Sandboxes not protect against?
Docker's documentation lists several limits: a direct workspace mount is read-write, so git hooks, CI files and scripts the agent writes land on the host; local stdio MCP servers run on the host with host permissions; remote MCP servers run outside the sandbox; the default network allowlist is broad; and read-write skill stores put sandboxes in a shared trust boundary.
Does Docker AI Governance see agents that run outside a sandbox?
Its audit records cover sandbox policy decisions and sandbox session events, so an agent launched directly from a terminal, an MCP server configured directly in an agent's settings, or AI used through the browser is outside its view. That is inherent to isolation: a sandbox governs the sessions that start inside it.
How does Anomity help with this?
Anomity's Endpoint Sensor inventories the agents, MCP servers, extensions, plugins, skills and hooks configured on every managed machine, whether or not they run in a sandbox, and finds secrets in AI tool configs, redacted on the endpoint. The Browser Sensor covers AI web services and personal accounts, cloud discovery covers OAuth grants, and hook enforcement can allow, deny or log tool calls for agents running directly on the host.




