Skip to content

Product Independently confirmed2 publishers 3 min read Published Updated

Docker's Kit spec v3 writes an AI agent's access into an ordinary OCI image

Docker published its Sandbox Kit Specification v3 under Apache 2.0, packaging an AI agent's permissions and tools as an ordinary OCI image. Grants that developers now keep in shell history and run flags can be pinned by digest and reviewed like any other image change.

The Product Desk

Send a correction

Illustration accompanying Docker's Kit spec v3 writes an AI agent's access into an ordinary OCI image
Generated illustration

What happened

  • Docker published the Docker Sandbox Kit Specification v3 as open source under the Apache 2.0 licence, in the docker/sandbox-kit-spec repository.
  • Kits already existed in Docker's sbx tool; v3 is the format's third version and the first in which a Kit is an ordinary OCI image.
  • A v3 Kit needs no new media type or sidecar file, so existing registries can store and serve it without learning anything new.
  • Kits come in two kinds: one workload that supplies the root filesystem, plus any number of mixins such as a CLI with its network rule or a credential binding.

Why it matters

  • What's now possible capability Access granted to an agent can be pinned by digest, so two versions can be compared and a colleague who pulls the same digest gets the same grants.
  • Who has to decide decision Teams have to choose which grants leave docker run flags, Compose files and CI configs for a Kit, and which stay outside anything that gets reviewed.
  • Who's exposed exposure With grants sitting in a readable manifest annotation, the reviewer who approves a broad one is on record as having seen it.

A firewall rule gets opened because opening it was quicker than narrowing it. The author of Docker's announcement post lists that among the grants they give their own agents, beside a bind mount and a token with broader scope than the task needs [8]. "The holes are configuration, added on purpose, usually by me," the author wrote [9].

What teams tell themselves is that the sandbox is the control. A Docker Sandbox is a microVM with its own kernel, and the post argues that puts the boundary below anything the model can reach or rewrite [7]. What users do, by the author's own account, is widen that boundary one request at a time and lose the record of it. "No file records them. They live in shell history, dashboards, and my memory. I cannot hand that to a colleague or diff it against last week," the author wrote [10].

The spec goes after the record. A Dockerfile describes the software, and the post says the outside of it (networks, credentials, volumes, tools, context) has lived in docker run flags, Compose files, CI configs and someone's memory [13]. The Kit puts those declarations in one manifest annotation, vnd.docker.sandbox.kit.descriptor, while the image layers carry the content [3]. Pinning the digest pins both [5].

This is for the second person: the colleague who inherits an agent, or the reviewer who signs off on what it can reach. Distribution asks nothing new of them. Kits build with docker buildx build, pull with docker pull, and get scanned and signed by tooling teams already run [4]. The format itself has a cost. "The tooling and distribution path are free; the format is something you learn," the author wrote, and the list runs to a grammar, a page per capability type, provides and requires, and kind: set [12].

A declared grant is as broad as its author made it. In the post's GitHub CLI mixin, the allow rule for api.github.com lists six methods, DELETE among them, and the deny rule removes DELETE only for paths under /repos/** [11][16]. A reviewer can now see that choice in a diff. Whether DELETE should stay open anywhere else on that API is still the reviewer's call.

The post says a Kit means the same thing on any conforming runtime [17]. It does not name a conforming runtime other than Docker's own, and it includes no adoption figures.

I'd move an agent's grants into a Kit whenever someone other than the person who granted them will have to answer for them. The tradeoff is learning another capability page for each grant type in use. For the rest, two axes sort the agents a team runs: whether the grants sit in the image digest, and whether the agent runs in a microVM or in a container on the host kernel. Declared grants in a microVM are the case the spec was written for. Declared grants in a container give a reviewable record over what the post calls "the same kernel the actor is probing" [14]. An undeclared microVM keeps damage inside the sandbox boundary [7] but cannot be rebuilt on a colleague's laptop. The last box, undeclared and in a container, is where the author says their own grants lived: shell history, dashboards and memory [10].

What to watch

  • A runtime other than Docker's claiming conformance to v3, the first test of the post's promise that a Kit means the same thing on any conforming runtime.
  • Whether registry and signing tools start showing the vnd.docker.sandbox.kit.descriptor annotation on review screens, or reviewers keep reading it by hand.
  • Whether the credential capability type can scope a token to a single task, given that an over-scoped token is one of the grants the post's author admits to.

Clarity's read

What the record supports and how the coverage leans. The claims behind it follow.

Reality

Evidence60
Adoption20
Hype gap+25
Incentives70
Confidence65
Why these scores

Claim ledger

Ranked by verification strength, evidence, and original report placement.

  1. [1]

    Docker published the Docker Sandbox Kit Specification v3, open source under Apache 2.0 at docker/sandbox-kit-spec.

    Reported Supported Source: Docker announcement blog postView cited source
  2. [2]

    In v3 a Kit is an ordinary OCI image rather than its own artifact: no media type, no sidecar file, nothing for a registry to learn.

    Reported Supported Source: Docker announcement blog postView cited source
  3. [3]

    The Kit's manifest carries the declarations in one annotation, vnd.docker.sandbox.kit.descriptor; the layers carry the content.

    Reported Supported Source: Docker announcement blog postView cited source
  4. [4]

    A Kit builds with docker buildx build, pulls with docker pull, gets scanned and signed by the tooling users already run, and works in a FROM.

    Reported Supported Source: Docker announcement blog postView cited source
  5. [5]

    Pinning a Kit's digest pins content, declarations, and metadata together.

    Reported Supported Source: Docker announcement blog postView cited source
  6. [6]

    Two kinds of Kit exist: a workload runs and supplies the root filesystem; a mixin is an overlay such as a CLI with its network rule, a credential binding, or context for an agent. Users launch one workload and any number of mixins.

    Reported Supported Source: Docker announcement blog postView cited source
  7. [7]

    A Docker Sandbox is a microVM with its own kernel, so the boundary sits below anything the model can reach or rewrite; the damage stops at the sandbox boundary.

    Reported Supported Source: Docker announcement blog post, author's argumentView cited source
  8. [8]

    The post's author grants agents access one piece at a time: a bind mount, a token with broader scope than the task needs, a firewall rule that was quicker to open than to narrow.

    Reported Supported Source: Docker announcement blog post author, first-person accountView cited source
  9. [9]

    "The holes are configuration, added on purpose, usually by me."

    Reported Supported Source: Author of the Docker announcement post (unnamed in supplied text)View cited source
  10. [10]

    "No file records them. They live in shell history, dashboards, and my memory. I cannot hand that to a colleague or diff it against last week."

    Reported Supported Source: Author of the Docker announcement post (unnamed in supplied text)View cited source
  11. [11]

    Part of the GitHub CLI mixin shown in the post allows github.com and api.github.com with methods GET, HEAD, POST, PATCH, PUT, DELETE, and denies DELETE on api.github.com for paths /repos/**.

    Reported Supported Source: Docker announcement blog post, excerpt of repository mixinView cited source
  12. [12]

    "The tooling and distribution path are free; the format is something you learn: a grammar, a page per capability type, provides and requires, kind: set."

    Reported Supported Source: Author of the Docker announcement postView cited source
  13. [13]

    A Dockerfile does not describe the outside: networks, credentials, volumes, tools, context. That half has lived in docker run flags, a Compose file, a CI config, and someone's memory. "Unversioned, unreviewable." A Kit writes it down with the content.

    Reported Supported Source: Docker announcement blog postView cited source
  14. [14]

    "A container was not built for that: the boundary is the same kernel the actor is probing."

    Reported Supported Source: Author of the Docker announcement postView cited source
  15. [15]

    Users of sbx have already used Kits; v3 is the third version of the format, and the change in this version is that a Kit is now an ordinary OCI image rather than its own artifact.

    Reported Supported Source: Docker announcement blog postView cited source
  16. [16]

    The GitHub CLI mixin's allow rule for api.github.com lists six HTTP methods.

    Derived Supported
  17. [17]

    A Kit's answer travels with the agent and means the same thing on any conforming runtime.

    Reported Insufficient Source: Docker announcement blog postView cited source

Sources

2 independent publishers whose own reporting we read for this story.

  1. docker.com

    1 article · September 24, 2026

    From Dockerfile to Kit: the Docker Sandboxes Kit Specification
  2. infoq.com

    1 article · October 2, 2026

    Docker Sandbox Kit Spec: Packaging AI Agent Permissions as OCI Images

Topics and entities

Entities