On November 19, 2026, Docker launched a new brand built around one message: "Run on Trust". The whale got a redesign, the website changed, and the story moved toward AI agents. A viral version of the news has been going around, and some of it is wrong. I care less about the logo than about what Docker Run on Trust says about AI agent security, because that is the problem platform, DevSecOps and SRE teams are being handed right now.
What Docker actually announced
The primary source is Docker CMO Terri Avnaim's post, "Meet the New Docker: Built to Run on Trust". A few corrections to what I have seen shared:
- "Build, Ship, Run" was not formally retired. "Run on Trust" is the new line, but the Docker homepage still says Docker "securely contains autonomous agents so you can confidently build, ship, and run on trust." The old lifecycle language now sits under a trust-first message.
- The three pillars are Trusted Runtime, Trusted Supply Chain and Trusted Ecosystem. AI Governance is a real product, but it is not a pillar.
- The whale is redesigned, not retired. The brand guidelines say the identity is "built around two ideas: containment and the whale."
- Containers are staying. In Avnaim's words: "The containers you know and love aren't going anywhere."
The line from the announcement that matters most to me is this one: "Containers isolate workloads. But agents aren't workloads. Agents are actors." An agent decides what to run, what to access and what to change. That is a different threat model from a web service with a fixed entrypoint, and I think Docker is right to name it.
Why Docker AI agent security is a platform problem
Many teams did not plan for agents. A developer installs a coding agent, gives it a terminal, and it starts pulling images, calling tools and touching credentials. Each of those is a trust decision that used to be made by a human or by a pipeline with fixed steps. Now a model makes it.
You do not need Docker's products to fix this. But Docker's launch is a useful map of the layers you need to think about, so I will use it as one.
1. Sandbox the agent, not only the app
Docker's answer for the runtime is Docker Sandboxes. Docker describes each sandbox as an isolated microVM with its own kernel and a private Docker Engine. Docker says this is a hardware boundary rather than a shared-kernel container, and that it avoids Docker-in-Docker privilege issues when an agent builds images. The product page also says credentials never enter the VM; the real secret stays on the host.
Docker's president Mark Cavage put the reasoning plainly in the September Cloud Sandboxes press release: containers "weren't designed for the level of isolation AI agents demand."
One caveat. I did not find an independent security evaluation of the microVM boundary or the credential handling. These are Docker's claims, and you should test them against your own threat model before you lean on them.
2. Put supply chain evidence under every image an agent touches
If an agent can pull and build images, a bad base image stops being a backlog ticket and becomes an autonomy problem. Treat "the agent found a handy image on the internet" as an untrusted pull.
Docker's piece here is Docker Hardened Images. Docker says they ship with signed SBOMs, SLSA Level 3 provenance and continuous patching, and the homepage claims "near-zero CVEs." Two patch numbers float around, and they are different metrics: the homepage shows "CVE patch time on Hardened Images: <24h," while the product page says Select and Enterprise customers get critical CVE fixes "within 7 days under an SLA." Do not mix them up.
Docker Scout reads an image's SBOM, cross-references CVE data and evaluates policy. A minimal check in CI might look like this (replace the placeholders):
# Placeholders: <REGISTRY>/<IMAGE>:<TAG>, <PUBLIC_KEY_FILE>
docker scout sbom <REGISTRY>/<IMAGE>:<TAG>
docker scout cves --only-severity critical,high <REGISTRY>/<IMAGE>:<TAG>
# If your images are signed with cosign, check the provenance attestation too
cosign verify-attestation --type slsaprovenance \
--key <PUBLIC_KEY_FILE> <REGISTRY>/<IMAGE>:<TAG>
For Hardened Images specifically, follow Docker's verification docs rather than guessing at the key and attestation format. The point is the gate, not the tool: no evidence, no deploy.
3. Govern tools and credentials, not only the runtime
Agents get dangerous when they can call tools, production APIs or cloud keys with broad authority. Docker's controls here are the MCP Catalog and Toolkit, a curated set of containerized MCP servers with provenance and SBOM metadata, and the MCP Enterprise Gateway, which Docker says sits between agents and MCP servers, applies policy, and injects credentials at call time so the agent never holds the key.
On top of that sits Docker AI Governance. Docker's November 18 explainer splits it into Sandbox Policies, MCP Tool Governance (with organization policies written in Cedar) and Audit + Visibility that can stream to a SIEM. My favorite line in it: "A model decision is not automatically an authorized action."
The same post is honest about a limit, and you should know it. MCP policies cover traffic that goes through Docker's MCP Gateway. A direct connection from a sandbox to a remote MCP server falls under the sandbox network policy instead. Its read-only example also relies on a server-supplied readOnly annotation that the post itself calls advisory. A gateway only governs what passes through it, so close the side doors.
4. Enforce policy where the agent actually runs
The real failure mode with coding agents is a different local config on every laptop. Docker pitches AI Governance as central network, filesystem and MCP policy, pushed through existing identity (SAML/SCIM), with no local override and an audit record of who did what under which rule.
This is not a new lesson. It is admission control and policy as code, applied to a new kind of actor: define the boundary, enforce it at execution time, and keep the evidence. Whatever tool you use, the policy should live somewhere the agent cannot edit.
A practical checklist for running AI agents
- [ ] Inventory which agents your engineers run today, and where.
- [ ] Run agents in an isolated environment with its own boundary, not on the bare host or a shared-kernel sidecar by default.
- [ ] Keep real secrets out of the agent's environment and context. Inject credentials at call time where you can.
- [ ] Approve a small catalog of tools and MCP servers. Block everything else at the network layer, not only at the gateway.
- [ ] Gate images that agents pull or build on SBOM, CVE policy and signed provenance.
- [ ] Manage agent policy centrally through your identity provider, with no local override.
- [ ] Send agent audit events to your SIEM and alert on denied actions.
- [ ] Test vendor isolation claims yourself before you widen an agent's permissions.
My take
The rebrand is the public signal of a year of product work, and I think the framing is right: agents are actors, and actors need boundaries, evidence and policy. I would not treat any single vendor as the whole answer, and I would attribute every isolation claim to whoever made it until someone tests it independently. But if your team is about to give agents more autonomy, the three questions in Docker's pillars are worth answering either way: where does the agent run, what did it build from, and who decided what it may touch.
I write more about platform security and cloud operations on my site, nazmul-ahasan.pro.bd.
I lead platform engineering for fintech. See more of my work or how we can work together at Nazmul Ahasan.
Top comments (0)