Docker's "Meet the New Docker: Built to Run on Trust" post, published on 19 November 2026, is mostly a brand and positioning change: a redesigned Moby whale and a focus on isolating and governing AI agents. It does not ask you to change how you build or run containers, and the post says "the containers you know and love aren't going anywhere." The practical part for developers is Docker Sandboxes, a way to run a coding agent such as Claude Code in an isolated microVM.
Who this is for and what you will have
This guide is for developers and platform teams who see the rebrand headlines and want to know two things: what actually changed, and whether the new sandbox tooling is worth trying for AI coding agents. By the end you will know what Docker has confirmed, what it left unsaid, how a sandbox is isolated, and the documented commands to start one, check its network policy and clean it up.
Several Docker docs pages could not be opened during research (the install and supported-agents pages returned errors), so this article does not list install commands or the full agent list. Follow the install page linked in References for those.
What Docker actually announced
The rebrand post is by Docker's chief marketing officer, Terri Avnaim. These are the points it makes, in Docker's own words where quoted.
| Topic | What the post says |
|---|---|
| Brand | A new brand built with the agency Motto and a redesigned Moby whale |
| Continuity | "This is about building on that foundation, not replacing it" |
| Containers | "The containers you know and love aren't going anywhere" |
| Principles | Still committed to openness, developer-first and simplicity |
| Trust areas | A trusted supply chain for agents to build from, a trusted runtime to isolate agents, and a trusted ecosystem |
| New products listed | Docker Sandboxes ("Isolated environments for coding agents"), Docker AI Governance ("Govern agents and Claws across every team") and an MCP Enterprise Gateway ("Connect and manage MCP tools") |
The post frames agents differently from ordinary software: "agents aren't workloads... Agents are actors." That is the reasoning behind a runtime built to isolate them rather than just run them.
What did not change
The post announces no change to the docker CLI, image format, Compose or Docker Desktop, and it gives no new subscription prices. The page checked on 2026-11-21 simply links to the pricing pages. If you read social posts claiming a product or licensing change, treat them as unverified until they appear on docker.com or docs.docker.com.
Docker's pricing page, checked the same day, shows these per-user monthly prices (the headline figure is billed annually):
| Plan | Monthly billing | Annual billing |
|---|---|---|
| Personal | $0 | Not applicable |
| Pro | $11 | $9 |
| Team | $16 | $15 |
| Business | Not offered | $24 |
Prices are before tax and may differ by region or promotion.
How a Docker Sandbox isolates an agent
Docker's Sandboxes security page describes five layers. Reading them tells you what the isolation protects and what it does not.
- Hypervisor: each sandbox runs in its own microVM with a separate kernel, so it shares no memory or processes with the host.
- Network: outbound TCP goes through a host proxy under a deny-by-default policy. UDP is blocked unless you enable an experimental feature and allow it, and ICMP is blocked.
- Docker Engine: each sandbox has its own Docker Engine and no path to the host daemon. The architecture page adds that each sandbox keeps its own daemon state, image cache and packages, so sandboxes do not share images or layers.
- Workspace: access depends on the mount mode (below).
- Credentials: the host-side proxy adds authentication headers to requests, and Docker states that credential values never enter the VM.
The trade-off, per the architecture page, is higher resource overhead than a plain container in exchange for hypervisor-level isolation.
Mount modes: read this before the first run
How the agent sees your code is the biggest decision you make.
| Mode | What the agent gets |
|---|---|
Direct mount (default for sbx run, using the current directory) | Read-write access to your working tree; changes appear on your host immediately |
--clone | Your repository mounted read-only, with the agent working on a private clone inside the VM |
| Mountless | No host workspace shared |
If you are trying an agent on code you care about, the clone mode is the more conservative choice. Docker's usage guide covers clone mode; check it for the exact workflow to bring changes back out.
Run a coding agent in a sandbox
The commands below are the ones Docker's get-started page documents. You need the sbx command-line tool installed and a Docker sign-in first.
Step 1: start the agent
From your project directory:
cd ~/my-project
sbx run --name my-sandbox claudeRunning sbx run without a workspace path mounts the current directory read-write. Replace claude with another agent from Docker's Agents page.
Step 2: choose the network policy up front
If you do not want the interactive prompt, set a preset before the run:
sbx policy init balanced
sbx run --name my-sandbox claudeThe three presets, from Docker's local policy page, are:
| Preset | Name | Behavior |
|---|---|---|
| Open | allow-all | All outbound TCP traffic is allowed |
| Balanced | balanced | Default deny with a baseline allowlist for AI provider APIs, package managers, OS package repositories, code hosts, container registries, cloud services and certificate validation |
| Locked Down | deny-all | No baseline allow rules; every destination needs a rule from you or a kit |
Under Balanced and Locked Down, unmatched destinations are blocked and wait for your approval. The security page warns that the default allowed list includes broad wildcards such as *.googleapis.com, which cover more than AI APIs. Review what you inherited:
sbx policy lsStep 3: allow only what the task needs
Docker documents these allow rules:
sbx policy allow network registry.npmjs.org
sbx policy allow network "myhost:22"The second form allows a TCP port on a host, such as SSH. The command sbx policy allow network "**" is equivalent to the Open preset, so avoid it unless you intend that. The pages opened for this article did not show how to remove or deny a rule, so check the "Manage local network rules" page in the Docker docs before relying on that.
Step 4: provide credentials without handing over keys
Docker's page documents storing a secret with sbx secret set rather than putting it in the VM. For GitHub access:
sbx secret set github --command 'gh auth token'For Claude Code with a Claude subscription (Max, Team or Enterprise), the page says to run /login inside the sandbox to sign in with OAuth. Because the host proxy injects authentication headers, the agent inside the VM does not see raw API key values.
Step 5: list, stop and remove
sbx ls
sbx stop my-sandbox
sbx rm my-sandboxSandbox contents persist until you remove them, including images, packages and agent history. Files in a directly mounted workspace live on your host instead, so removing the sandbox does not delete them.
What the sandbox does not protect
Docker's own limits list is blunt, and it matters more than the marketing.
- The agent has full root-level control inside the VM, including sudo.
- In direct-mount mode, files that run implicitly can affect your host: Git hooks in
.git/, CI configs, aMakefile,package.jsonscripts and similar. Git hooks do not appear ingit diff, so inspect.git/hooksafter an agent session. - Local stdio MCP servers run on the host, not in the VM, so they use host permissions. Remote MCP servers run outside Docker Sandboxes.
- Kit installs run as root and are limited by default to Docker Hub as a source.
- Shared agent skills with
readwriteaccess put the sandboxes that share them in one trust boundary.
Docker's documentation also says that MCP policies in the governance product cover traffic through Docker's MCP gateway, while direct sandbox-to-remote traffic falls under the network policy. In practice, if you connect an agent to MCP tools, decide where each server runs and what it can reach before you trust the sandbox boundary.
Costs and who needs the paid parts
Docker's pricing page, checked 2026-11-21, says local sandboxes are free for every developer, including commercial and professional work, with no Docker Desktop required. You bring your own key for model inference, and model-provider charges are separate.
Cloud Sandboxes run on Docker-managed compute and are pay-as-you-go with no recurring subscription fee. The listed hourly rates are:
| Size | vCPUs | Memory | Per hour |
|---|---|---|---|
| Micro | 1 | 2 GB | $0.07 |
| Small | 2 | 4 GB | $0.14 |
| Medium | 4 | 8 GB | $0.28 |
| Large | 8 | 16 GB | $0.56 |
| XL | 16 | 32 GB | $1.12 |
A paused cloud sandbox costs nothing, per the page. As a worked example, a Medium sandbox running 6 hours a day for 20 days is 6 x 20 x $0.28 = $33.60, before model charges. Centrally managing sandbox network, filesystem and MCP policies across an organization is, per the sandboxes overview, available on a separate paid subscription.
Troubleshooting and checks
| Symptom | What to check |
|---|---|
| The agent cannot reach a package registry or API | Run sbx policy ls, then add the specific host with sbx policy allow network <host> |
| The agent can reach far more than you expected | You are on Open, or the Balanced baseline includes broad wildcards; review sbx policy ls |
| Changes appear in your repo you did not expect | You used direct mount; inspect git status, Git hooks and build scripts, or use --clone next time |
| Prompted for a policy on every first run | No preset is set; run sbx policy init balanced (or another preset) first |
| Old preset used without a prompt | A preset from an earlier installation is reused without asking; check sbx policy ls |
A short checklist before using an agent on real code:
- Pick the mount mode deliberately; prefer
--clonefor unfamiliar projects. - Set a network preset instead of accepting a prompt by habit.
- Read
sbx policy lsand trim broad wildcards you do not need. - Store tokens with
sbx secret setinstead of pasting them into the session. - Review Git hooks, scripts and lockfiles after the session.
- Remove the sandbox with
sbx rmwhen finished.
See also
- What Are Claude Skills? How to Install and Use One Step by Step
- Apple Is Building an AI Agent (Reported): How macOS Controls AI Agents Today
- Anthropic IPO Explained: Founder Sales, Record Raise and What It Means for Claude Users
What we checked
- Opened Docker's "Meet the New Docker: Built to Run on Trust" post on 2026-11-21; the post date is 19 Nov 2026, it quotes "the containers you know and love aren't going anywhere", and it mentions no pricing change.
- Opened the Docker Sandboxes overview, get-started, security, architecture and local governance pages on docs.docker.com on 2026-11-21 and copied the
sbxcommands shown only from those pages. - Cross-checked the isolation claims between the security page (separate kernel, own Docker Engine, deny-by-default network) and the architecture page (own daemon state and image cache, hypervisor isolation).
- Checked the Docker pricing page on 2026-11-21 for plan prices and the Sandboxes rates; recalculated the worked example: 6 hours x 20 days x $0.28 = $33.60.
- Documented output: none is shown, because the pages we opened did not publish sample output for these commands.
- Not checked: the sbx install page and the supported-agents page returned errors on 2026-11-21, so install commands and the agent list are omitted. Nothing here was run on a live machine or sandbox; steps follow Docker's documentation as of that date. Claims about earlier launch dates of local or cloud sandboxes were not verified and are left out.
Last tested: 2026-11-21
References
- Docker blog, Meet the New Docker: Built to Run on Trust: https://www.docker.com/blog/meet-the-new-docker-built-to-run-on-trust/
- Docker Sandboxes overview: https://docs.docker.com/ai/sandboxes/
- Get started with Docker Sandboxes: https://docs.docker.com/ai/sandboxes/get-started/
- Sandboxes security: https://docs.docker.com/ai/sandboxes/security/
- Sandboxes architecture: https://docs.docker.com/ai/sandboxes/architecture/
- Local sandbox network policy: https://docs.docker.com/ai/sandboxes/governance/local/
- Docker pricing: https://www.docker.com/pricing/
Comments
Questions and tips are welcome. Comments are checked by the EpiFive team before they appear; please do not share passwords, phone numbers or other private details.