What Is Docker Agent?

Docker Agent is an open-source tool from Docker — makers of Docker Engine, Docker Desktop, Docker Hub, and Docker Scout — that lets you build, run, and share AI agents using simple configuration files instead of writing application code.

You describe what your agent does — its model, personality, tools, and teammates — in a YAML file. Docker Agent handles the LLM orchestration loop, tool execution, multi-agent delegation, and streaming output. You focus on what the agent should do, not how to wire it up.

# agent.yaml — this is all you need
agents:
  root:
    model: anthropic/claude-sonnet-4-5
    description: A coding assistant
    instruction: |
      You are an expert developer. Help users write clean,
      efficient code. Explain your reasoning step by step.
    toolsets:
      - type: filesystem
      - type: shell
      - type: think

$ docker agent run agent.yaml

That's it. Your agent can now read and write files, run shell commands, and reason through problems — all through an interactive terminal UI.

Without vs. with Docker Agent

The same coding assistant, written two different ways:

# ~30 lines of glue code, every project
import anthropic, json, subprocess
from pathlib import Path

client = anthropic.Anthropic()
MODEL = "claude-sonnet-4-5"
TOOLS = [
  {"name": "read_file", "input_schema": {...}},
  {"name": "write_file", "input_schema": {...}},
  {"name": "run_shell", "input_schema": {...}},
]

def dispatch(name, args):
  if name == "read_file":
      return Path(args["path"]).read_text()
  if name == "write_file":
      Path(args["path"]).write_text(args["content"])
      return "ok"
  if name == "run_shell":
      return subprocess.check_output(args["cmd"], shell=True).decode()

messages = [{"role": "user", "content": input("> ")}]
while True:
  resp = client.messages.create(
    model=MODEL, max_tokens=4096, tools=TOOLS,
    system="You are an expert developer…",
    messages=messages,
  )
  # …parse tool_use blocks, dispatch, append, loop…
  if resp.stop_reason == "end_turn": break

# agent.yaml — 8 lines, no glue code
agents:
  root:
    model: anthropic/claude-sonnet-4-5
    description: A coding assistant
    instruction: You are an expert developer.
    toolsets:
      - type: filesystem
      - type: shell

$ docker agent run agent.yaml

Why Docker Agent?

Most AI agent frameworks ask you to write Python or TypeScript to glue together models, tools, and workflows. Docker Agent takes a different approach: declare everything in config, run it with a single command.

Use Cases

What people build with Docker Agent today:

How It Works

Docker Agent follows a simple loop:

1. You define an agent in YAML — its model, instructions, tools, and sub-agents
2. You run it with docker agent run via TUI, CLI, or API
3. The agent processes your request — calling tools, delegating to sub-agents, reasoning step by step
4. Results stream back in real time

A few terms you'll see

Agent

An LLM with instructions, tools, and (optionally) sub-agents — the unit you define in YAML.

Tool

A function the agent can call, like read_file or shell. Tools come from built-in toolsets or external MCP servers.

MCP

Model Context Protocol — an open standard for tool servers. Docker Agent can use any MCP server as a toolset.

A2A

Agent-to-Agent — an HTTP protocol agents use to talk to each other across machines.

TUI

Terminal User Interface — the default interactive front end, launched by docker agent run.

OCI

The same registry format used for Docker images. Docker Agent reuses it to push and pull agents.

Zero Config

The fastest way to try it — no config file needed:

# Run the project config or built-in default agent
$ docker agent run

From the Registry

Run agents straight from any OCI-compatible registry — just like pulling a Docker image:

$ docker agent run myorg/agent:tag

Multi-Agent Teams

Build a team where a coordinator delegates tasks to specialists:

agents:
  root:
    model: openai/gpt-5
    description: Team coordinator
    instruction: Route tasks to the best specialist.
    sub_agents: [coder, reviewer]

  coder:
    model: anthropic/claude-sonnet-4-5
    description: Writes and modifies code
    instruction: Write clean, tested code.
    toolsets:
      - type: filesystem
      - type: shell

  reviewer:
    model: anthropic/claude-sonnet-4-5
    description: Reviews code for quality
    instruction: Review code for bugs, style, and best practices.
    toolsets:
      - type: filesystem

Non-Interactive Mode

Use --exec for scripting and automation:

# One-shot task
$ docker agent run --exec agent.yaml "Create a Dockerfile for a Node.js app"

# Pipe input
$ cat error.log | docker agent run --exec agent.yaml "What's wrong in this log?"

# Serve as an API
$ docker agent serve api agent.yaml --listen 127.0.0.1:8080

Part of the Docker ecosystem

Docker Agent reuses the tooling and conventions you already know:

Explore the Docs