# Docker's 'Run on Trust' Rebrand: What Changes and How to Sandbox AI Agents

> Docker's November 2026 rebrand changes the look and the AI focus, not your containers. See what Docker said and how to run a coding agent in a Docker Sandbox with a network policy.

Source: https://www.epifive.com/blog/docker-run-on-trust-rebrand-sandboxes-ai-agents · Published 2026-11-21 · EpiFive

## Key takeaways

- Docker's rebrand post of 19 Nov 2026 redesigns the Moby whale and brand, and says "the containers you know and love aren't going anywhere."
- The post names three areas of trust for agents - a trusted supply chain, a trusted runtime and a trusted ecosystem - and lists Docker Sandboxes and Docker AI Governance as new products.
- A Docker Sandbox runs a coding agent in its own microVM with a separate kernel and its own Docker Engine, so the agent has no path to the host Docker daemon.
- Network access from a sandbox is deny-by-default, but the Balanced preset still allows broad baselines such as AI APIs, package managers and code hosts, so review it with sbx policy ls.
- Direct-mount mode gives the agent read-write access to your working tree, and files such as Git hooks and package.json scripts can still affect your host, so review them.

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:

```bash
cd ~/my-project
sbx run --name my-sandbox claude
```

Running `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:

```bash
sbx policy init balanced
sbx run --name my-sandbox claude
```

The 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:

```bash
sbx policy ls
```

### Step 3: allow only what the task needs

Docker documents these allow rules:

```bash
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:

```bash
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

```bash
sbx ls
sbx stop my-sandbox
sbx rm my-sandbox
```

Sandbox 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, a `Makefile`, `package.json` scripts and similar. Git hooks do not appear in `git diff`, so inspect `.git/hooks` after 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 `readwrite` access 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:

1. Pick the mount mode deliberately; prefer `--clone` for unfamiliar projects.
2. Set a network preset instead of accepting a prompt by habit.
3. Read `sbx policy ls` and trim broad wildcards you do not need.
4. Store tokens with `sbx secret set` instead of pasting them into the session.
5. Review Git hooks, scripts and lockfiles after the session.
6. Remove the sandbox with `sbx rm` when finished.

## See also

- [What Are Claude Skills? How to Install and Use One Step by Step](https://www.epifive.com/blog/what-are-claude-skills-how-to-install)
- [Apple Is Building an AI Agent (Reported): How macOS Controls AI Agents Today](https://www.epifive.com/blog/apple-ai-agent-report-macos-agent-permissions)
- [Anthropic IPO Explained: Founder Sales, Record Raise and What It Means for Claude Users](https://www.epifive.com/blog/anthropic-ipo-explained-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 `sbx` commands 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/

## Frequently asked questions

### Is Docker changing its pricing with the Run on Trust rebrand?

The rebrand post does not mention a pricing change. Docker's pricing page, checked on 2026-11-21, lists Personal at $0, Pro at $11 monthly or $9 billed annually, Team at $16 or $15, and Business at $24 billed annually, per user per month. Compare those with your own invoice before assuming anything changed.

### Do I have to change my Dockerfiles or Compose files?

Nothing in Docker's rebrand post asks you to. The post says containers still play a huge role in the software development lifecycle and that Docker will keep leading there. Sandboxes are a separate, new product managed with the sbx command-line tool.

### Is Docker Sandboxes free?

Docker's pricing page says local sandboxes are free for every developer, including commercial work, and you bring your own model key. Cloud Sandboxes run on Docker-managed compute and are pay-as-you-go. Docker says managing sandbox policy centrally for an organization needs a separate paid subscription.

### Does a sandbox make an AI coding agent completely safe?

No. Docker's security page says the agent has root-level control inside the VM, and in direct-mount mode it edits your real files. Hooks, build scripts and local MCP servers can reach the host, so you still need to review what the agent changed.

