Docker puts a trust layer between AI agents and what they are allowed to do
On November 18, 2026, Docker unveiled AI Governance, a control layer that constrains AI agents at three levels: sandboxes, MCP tools, and audit. If you let an agent write code inside your organization, this is today’s most concrete runtime control — as long as you don’t mistake an annotation for a decision.
November 18, 2026. Docker publishes AI Governance, a control layer built to constrain the AI agents that execute code, access files, and call external tools. November 18, 2026. Karan Verma frames the problem up front: a model decision is not automatically an authorized action. November 18, 2026. The product reduces to three questions every security team must be able to answer — where can the agent operate, what can it do, and can we see what happened. Why it matters: most agent deployments still treat model behavior as the security boundary, and that is precisely the boundary a single request can cross.
A model decision is not an authorized action
Docker’s premise is easy to state and hard to dispute. As long as an AI only answers a question, security is about content. Once an agent can execute code, edit files, connect to services, or call tools, the question changes nature: how do you give an agent enough freedom to be useful without giving it more access than it needs?
The answer, Verma insists, cannot rest on the model alone. An agent’s behavior varies from one run to the next, whereas a security control has to be clear and enforceable. That means putting controls around the environment where the agent runs — what it can reach, which tools it can use, what happens when a policy allows or blocks an action. For a CISO, the trust gap boils down to this: approving agent use means answering far more than “is the model capable” — it means saying what access the agent has, where those boundaries are enforced, and what evidence remains afterward. The stated goal is to let teams adopt agents without making model behavior the security boundary.
This shift is no longer hypothetical. Coding agents now run inside CI/CD pipelines, edit repositories, and open pull requests; the question of what an agent is allowed to touch has become a production concern, not an academic one. Docker’s framing matters because it moves the conversation from “is the model safe” to “where is the boundary enforced” — a question with a technical answer rather than a probabilistic one.
Three questions, three controls
Docker AI Governance organizes its answer around three pillars that map to three operational questions: Sandbox Policies answer “where can the agent operate,” MCP Tool Governance answers “what can it do,” and Audit + Visibility answers “can we see what happened.”
Sandbox Policies — the execution space. Each agent runs inside a Docker Sandbox, an isolated microVM with its own Docker Engine, filesystem, and network. Governance adds a centrally managed policy on top of that environment. Network rules allow or block specific domains, IP ranges, and ports; filesystem rules control which host paths can be mounted, as read-only or read-write. The decisive point is that these controls are enforced at the network proxy and filesystem mount layers, not in an instruction the agent is expected to obey. A developer can check the effective boundary before launching the agent:
$ sbx policy check network api.anthropic.com
Allowed: api.anthropic.com
$ sbx policy check network blocked.example.com
Denied: blocked.example.com The answer comes from the active policy, not from a prompt instruction. The same boundary follows developers from one sandbox to the next instead of being reconfigured on every machine, and an individual agent cannot widen its boundaries on its own.
MCP Tool Governance — access to tools. The Model Context Protocol gives agents a common way to connect to tools and services, which widens what an agent can act on. Making a tool available should not mean any agent can use it. Docker therefore places policy around the MCP activity that passes through its gateway: which MCP servers can be registered, which tool calls, resources, or prompts are allowed, and which actions require approval. These policies are written in Cedar, an authorization policy language, with a deny-by-default logic — a governed request is denied unless a matching policy permits it.
permit (principal, action == MCP::Action::"invokeTool", resource)
when {
resource in MCP::Server::"example" &&
resource.readOnly == true
}; Here, readOnly comes from the MCP tool’s annotations, supplied by the server. The nuance matters: those annotations are advisory, not a guarantee. A team can receive the tools it needs while other servers stay unreachable, and specific actions can require an additional checkpoint.
Audit + Visibility — traceability. Setting a policy is only half the job. Docker records sandbox policy decisions and session events as structured audit records — principal, action, target, decision, timestamp — without ever storing prompt or response contents. Records can stay local or be delivered to the cloud, to be searched organization-wide, exported, or pushed into a SIEM. Denied decisions are the most valuable: they show not only that an action failed, but which governance rule blocked it and why.
The limit of control by annotation
The announcement deserves a critical read, not a repost. Two limits stand out. First, MCP policies apply to activity that passes through Docker’s gateway: if an agent connects directly to a remote MCP server from inside a sandbox, that connection falls under the sandbox network policy, not the tool governance. The boundary exists, but it depends on the path the agent takes. Second, tool governance leans partly on server-declared annotations, which the post itself calls “advisory.” A policy built on readOnly == true is only as strong as the server’s declaration.
Alongside these runtime controls sits a supply-chain layer: Docker Hardened Images provide minimal, signed images with SBOMs, VEX, cryptographic signatures, and SLSA Build Level 3 provenance. That is the other half of the trust question — not “what is the agent doing,” but “where did what the agent builds come from.”
The verdict
If you run coding agents in your organization, Docker AI Governance is today’s most concrete runtime control you can deploy without building your own infrastructure: the sandbox isolates, policy is enforced at the proxy and mount layers rather than the prompt, and audit leaves you a usable trail afterward. Adopt it on the assumption that the sandbox network policy is the real enforcement point — it is what catches the direct connections that tool governance cannot see.
Do not, however, turn MCP annotations into a security decision: treat them as indicative metadata, require approval for sensitive actions, and validate your Cedar rules against real cases rather than the servers’ declarations alone. Docker’s underlying point holds: agent security is not won in the prompt, it is won in the environment — but the environment itself must be verified, not assumed.