Docker Agent
Docker · Docker Agent (formerly cagent): Open-Source Runtime for YAML-Defined AI Agent Teams
Docker Agent is Docker's free, open-source (Apache 2.0) tool for building and running AI agents and multi-agent teams from a YAML or HCL file instead of application code, run with `docker agent run` and shared through OCI registries like container images. It suits developers and platform teams who want repeatable agents with MCP tools and a choice of cloud or local models, without writing an agent loop themselves.
Best for
Developers and platform teams already using Docker who want versionable, shareable agents and multi-agent teams defined in config, with MCP tools and a free choice of cloud or local models
Not ideal for
Teams that want to express agent logic in Python or TypeScript code, people looking for a hosted agent service or a ready-made assistant, and organizations that cannot accept default-on telemetry or a fast-changing configuration format
Who it's for
Developers, DevOps and platform engineers who want to define, run, and share AI agents as configuration alongside their Docker workflows
Capabilities
- Agents and teams defined declaratively in YAML or HCL: model, instructions, toolsets, sub-agents, and hooks, with no application code
- Two multi-agent patterns: hierarchical delegation with `sub_agents` (each child runs in its own sub-session) and peer-to-peer `handoffs` that pass the full conversation, plus background agents for parallel work
- Built-in toolsets for filesystem, shell, background jobs, memory, todo and plans, RAG (BM25, embeddings, hybrid search, reranking), web fetch, LSP, OpenAPI, and more
- Any MCP server as a toolset (local, remote, or containerized through Docker's MCP Catalog), plus SKILL.md skills loaded on demand, including from public GitHub repositories
- Many model providers built in, including OpenAI, Anthropic, Google Gemini, AWS Bedrock, Mistral, xAI, OpenRouter, Azure OpenAI, and GitHub Copilot, with local models through Docker Model Runner or Ollama
- Several ways to run one config: interactive terminal UI, headless `docker agent run --exec`, HTTP API server with SSE streaming, OpenAI-compatible chat server, MCP server, ACP server for editors, and A2A server
- Push and pull agents to Docker Hub or any OCI registry with `docker agent share`, with optional signing so pullers can verify the publisher
- Tool safety modes (strict, balanced, restricted, autonomous) with allow, ask, and deny rules; served A2A, MCP HTTP, and chat endpoints default to the restricted mode
- Budgets that cap a run's cost in USD, tokens, or working time, shared across sub-agents
- Optional sandbox mode that runs the agent inside a Docker Sandboxes VM, locally or in the cloud (cloud mode requires a Docker login)
- `docker agent eval` replays recorded sessions in containers to score tool-call accuracy and responses
- Go SDK for embedding the agent runtime in Go applications
Limitations
- Configuration-first by design: complex control flow that a code SDK expresses directly has to fit YAML or HCL fields, hooks, and routing rules, or move to the Go SDK
- Supplies no model of its own. You need a provider API key, an account login such as ChatGPT or GitHub Copilot, or a local model, and you pay any model costs
- Telemetry is enabled by default. Docker's docs say command arguments, which can include prompts and file paths, may be sent, and recommend setting `TELEMETRY_ENABLED=false` for sensitive work
- Releases ship two or three times a week (eight releases from v1.141 to v1.149 between September 16 and October 7, 2026), and some releases reject config fields that older versions accepted
- The project docs site tracks the main branch and may describe features not yet in a release; Docker's stable docs are on docs.docker.com
- A2A support is described in the docs as early, with limited integration of tool calls, artifacts, and memory
- Docker Desktop bundling is the easiest install, but Docker Desktop requires a paid subscription for larger companies and government entities; the standalone binary and Homebrew avoid that dependency
Use cases
- Defining a bug-triage team where a root agent analyzes stack traces and delegates fixes to a coder agent with filesystem and shell tools
- Piping logs or alerts into a headless `docker agent run --exec` agent in CI or an ops script
- Publishing a team's agent config to a private OCI registry so colleagues run the same agent with one command
- Exposing a specialized agent as an MCP server so it can be called from Claude Code, Claude Desktop, or Cursor
- Running an agent on a local model through Docker Model Runner to keep prompts and data on the machine
- Serving an agent through an OpenAI-compatible endpoint to plug it into an existing chat UI such as Open WebUI
Our take
Docker Agent's useful idea is treating an agent as an artifact rather than a program: a config file you can diff, push to a registry, pull elsewhere, and run as a terminal app, API, MCP server, or editor agent without changing it. That makes it a practical way for Docker-centric teams to standardize and share agents, and the provider list, local-model support, safety modes, and budgets cover most of what an unattended run needs. The costs are the flip side of that design: logic that is awkward in YAML has nowhere to go except hooks or the Go SDK, telemetry must be switched off deliberately, and a release every few days means config written today may need updates. Pin a version, disable telemetry for sensitive work, and start with one small team before standardizing on it.
Who should use it
Developers, DevOps and SRE teams, and platform engineers who want to define agents as reviewable config, reuse MCP tools across them, mix cloud and local models, and distribute agents through the registries they already use for images.
Who should skip it
Teams that prefer writing agent logic in Python or TypeScript, anyone wanting a hosted no-setup assistant, and organizations that need a slow-moving, stable configuration surface or cannot accept default-on telemetry.
Strengths
- Free and open source under Apache 2.0, from a major developer-platform vendor
- Agents are plain config files that can be versioned, reviewed, and shared through OCI registries
- One config runs as a TUI, headless CLI, HTTP API, OpenAI-compatible endpoint, MCP server, ACP server, or A2A server
- Works with many cloud providers and with local models through Docker Model Runner or Ollama
- Safety modes, budgets, and an optional VM sandbox give controls for unattended runs
Weaknesses
- Less flexible than writing orchestration in code
- Telemetry is on by default and can include command arguments
- Very fast release cadence means frequent config and behavior changes
- Docker Desktop bundling requires a paid Docker subscription at larger companies (the standalone binary does not)
Docker Agent pricing
Open source
Free
- Apache 2.0 license
- Standalone binaries for macOS, Linux, and Windows, Homebrew, and WinGet
- Bundled with Docker Desktop 4.63 and later
- All run modes, MCP, multi-agent teams, and OCI distribution included
Note: Docker Agent itself is free. Model usage is billed by whichever provider you configure, and local models through Docker Model Runner or Ollama have no API cost. Docker Desktop, one way to get Docker Agent, is free for personal use, education, non-commercial open source, and businesses with fewer than 250 employees and less than $10 million in annual revenue; larger organizations and government entities need a paid Docker subscription to use Docker Desktop.
Technical specs
Where Docker Agent excels
Debugging with a two-agent team
Docker's docs show a root investigator agent that reads stack traces and code, then hands the diagnosed issue to a fixer agent with filesystem and shell access, each on its own model.
Headless agents in CI and ops scripts
`docker agent run --exec` accepts piped input such as a log file, and the restricted safety mode denies destructive or unknown tool calls without prompting during unattended runs.
Sharing a standard agent across a team
`docker agent share push` publishes the config to Docker Hub or a private registry, and colleagues run the same version with `docker agent run myorg/agent:tag`.
Adding a custom specialist to Claude Code
`docker agent serve mcp` exposes an agent team as MCP tools, so a coding assistant can call a domain-specific agent with its own model and tools.
Docker Agent vs. competitors
Docker Agent vs. CrewAI
CrewAI is a Python framework whose crews are defined in JSONC or YAML config files or in Python code, run inside a Python project, and can be deployed on its hosted platform for monitoring. Docker Agent defines teams in a YAML or HCL file and runs them from a single Go binary as a TUI, API, MCP, ACP, or A2A server, with OCI-registry sharing. CrewAI suits Python developers embedding agents in applications and extending them with Python tools, and Docker Agent suits teams that want agents as portable configuration without a Python environment.
Docker Agent vs. goose
goose is a ready-to-use desktop and CLI agent with MCP extensions, subagents, and shareable YAML recipes that can also run headless in CI. Docker Agent centers on defining custom agents and multi-agent teams in config, serving them over MCP, ACP, A2A, an HTTP API, or an OpenAI-compatible endpoint, and distributing them through OCI registries. goose suits people who want a general-purpose agent with a desktop app, and Docker Agent suits teams building and sharing their own agents.
Docker Agent vs. TrueForge
TrueForge is an open-source harness for production agents with persistent sessions, approval gates, a chat UI, an HTTP API, and a TypeScript SDK, deployed with SQLite locally or Postgres and Redis when hosted, and a managed version from TrueFoundry. Docker Agent is a single CLI binary built around YAML-defined teams, Docker tooling, and OCI distribution, with no managed service.
Frequently asked questions
What is Docker Agent?
Docker Agent is an open-source tool from Docker for building, running, and sharing AI agents. You define an agent or a team of agents in a YAML or HCL file, naming each agent's model, instructions, tools, and sub-agents, and `docker agent run` handles the model loop, tool calls, delegation, and streaming output.
Is Docker Agent the same as cagent?
Yes. Docker's documentation says the feature was called cagent in Docker Desktop versions 4.49 through 4.62 and is called Docker Agent from Docker Desktop 4.63. The command is now `docker agent` (or the standalone `docker-agent` binary).
Is Docker Agent free?
Yes. Docker Agent is open source under the Apache 2.0 license. You pay only for the models you use through your own provider accounts, and local models through Docker Model Runner or Ollama have no API cost. If you get it through Docker Desktop, Docker Desktop's own license terms apply, which require a paid subscription at companies with 250 or more employees or $10 million or more in annual revenue, and for government entities.
Do I need Docker Desktop to use Docker Agent?
No. Docker Desktop 4.63 and later include it, but you can also install it with Homebrew, WinGet, or a standalone binary for macOS, Linux, or Windows. Docker Desktop is useful for containerized MCP tools and Docker Model Runner, and a container runtime is required for `docker agent eval`.
Which models does Docker Agent support?
It has built-in providers for OpenAI, Anthropic, Google Gemini, AWS Bedrock, Mistral, xAI, DeepSeek, Groq, OpenRouter, Azure OpenAI, GitHub Copilot, a ChatGPT account login, and many others, and it runs local models through Docker Model Runner, Ollama, or other OpenAI-compatible servers. Agents in the same team can use different models.
Is Docker Agent the same as Gordon?
No. Gordon (`docker ai`) is Docker's built-in AI assistant. Docker Agent is a framework and runtime for building and running your own custom agents and agent teams.
Can I use Docker Agent agents from Claude Code or my editor?
Yes. `docker agent serve mcp` exposes agents as MCP tools for clients such as Claude Code, Claude Desktop, and Cursor, and `docker agent serve acp` connects them to editors that support the Agent Client Protocol, such as Zed. There are also HTTP API, OpenAI-compatible chat, and A2A server modes.
Docker Agent vs CrewAI: what is the difference?
Both let you define agent teams in config files. CrewAI is a Python framework, with a hosted platform, where agents and tasks live in JSONC files (YAML in classic projects) or directly in Python code, and crews run inside a Python project with Python tools and Flows for custom logic. Docker Agent is a single Go binary where the whole team lives in one YAML or HCL file that is run from the Docker CLI, served over MCP, ACP, A2A, or HTTP, and shared through OCI registries. CrewAI fits Python teams building agent logic into applications; Docker Agent fits teams that want agents as portable config with no Python environment.
Integrations & fit
Alternatives to consider
CrewAI
Orchestrating autonomous agent teams for enterprise tasks
Freemium
Agentic AI Foundation (Linux Foundation)
Developers and technical teams who want a free, vendor-neutral agent on their own machine, with a desktop app as well as a CLI, MCP extensions, and shareable recipes they can schedule or run in CI
Free
TrueFoundry
Platform and application teams that want a model-neutral, self-hosted runtime for reusable production agents
FreeAbout Docker Agent
Docker Agent, called cagent in Docker Desktop 4.49 through 4.62, takes a different approach from code-first agent SDKs: you describe each agent's model, instructions, toolsets, and teammates in a YAML (or HCL) file, and the runtime handles the LLM loop, tool execution, delegation, and streaming. A root agent can delegate tasks to `sub_agents`, which run in their own sub-sessions with their own model and context, or pass the conversation along through `handoffs` for pipeline-style routing, and background agents can run independent tasks in parallel. Built-in toolsets cover the filesystem, shell, memory, todo and planning, RAG, web fetch, LSP, OpenAPI, and more, and any MCP server can be added, including containerized servers from Docker's MCP Catalog. Models are not tied to one vendor: OpenAI, Anthropic, Google Gemini, AWS Bedrock, Mistral, xAI, OpenRouter, Azure OpenAI, GitHub Copilot, and many other providers are built in, and local models run through Docker Model Runner or Ollama, so different agents in one team can use different models. The same config can be run in several ways: an interactive terminal UI, headless `--exec` runs for scripts and CI, an HTTP API server, an OpenAI-compatible chat endpoint, an MCP server for clients such as Claude Code or Claude Desktop, an ACP server for editors, or an A2A server. Agents are pushed to and pulled from Docker Hub or any OCI registry with `docker agent share`, optionally signed. Docker Agent ships inside Docker Desktop 4.63 and later, and is also available through Homebrew, WinGet, and standalone binaries for macOS, Linux, and Windows. The tradeoffs: the YAML-first model is less flexible than writing orchestration in Python or TypeScript (a Go SDK exists for embedding), you supply and pay for the models, telemetry is on by default, and the project ships a new release every few days, so config fields and behavior change often. Docker's documentation also notes it is separate from Gordon, Docker's built-in AI assistant.
Updates from Docker Agent
Skills can now be loaded from public GitHub repositories by URL in an agent's `skills:` entries. The release also added a dedicated evaluator backend for `docker agent eval`, routed evaluators through the models gateway by default, and fixed OpenAI service-tier pricing and several TUI issues.
A new `routing` block with `allowed_agents` and `default_agent`, plus `before_agent_run` and `after_agent_complete` hook events, lets hooks decide which agent runs. `docker agent debug tool` calls a tool directly outside the LLM loop, and `--last` prints only the final answer in `--exec` runs.
Sandbox mode gained a `--cloud` option for running agents in cloud sandboxes without a local Docker dependency, and the ACP server added session management, client terminals, remote MCP servers, and audio prompts for editor integrations.
Are you the founder? Claim this listing →