# Docker Agent

> Docker's agent builder and runtime: describe agents and agent teams in YAML, give them MCP tools, and run them as a docker CLI plugin

- Category: Agents & Automation / Agent Frameworks & Builders
- Language: Go
- Licence: Apache-2.0
- Repository: https://github.com/docker/docker-agent
- Website: https://docker.github.io/docker-agent/
- Canonical page: https://ai-tldr.dev/tools/docker-agent/
- Updated: 2026-10-07

## In short

Docker Agent (`docker-agent`) is an AI agent builder and runtime from Docker Engineering. You create agents without writing code: each agent is a block in a YAML file with a model, a description, an instruction and a list of toolsets. It sits in the Agent Frameworks & Builders category of the Agents & Automation tools and is open-source, written in Go and licensed Apache-2.0.

## Overview

Docker Agent (`docker-agent`) is an AI agent builder and runtime from Docker Engineering. You create agents without writing code: each agent is a block in a YAML file with a model, a description, an instruction and a list of toolsets. It ships as a plugin for the `docker` CLI, so an agent runs with `docker agent run`, and Docker Desktop 4.63 and later already include it. Environment variables and some lint rules in its release notes still refer to the project's earlier name, cagent.

A single YAML file can describe a team instead of one agent. The README calls this a multi-agent architecture: specialised agents that delegate tasks to each other automatically. Tools come from built-in toolsets (think, todo and memory tools for reasoning) and from any Model Context Protocol server, whether it runs locally, remotely or as a Docker container — the README's example gives an agent DuckDuckGo search through `docker:duckduckgo`. Retrieval is pluggable, with BM25, embeddings, hybrid search and reranking.

Docker Agent is provider-agnostic. It works with OpenAI, Anthropic, Gemini, AWS Bedrock, Mistral, xAI and others, and with Docker Model Runner for local models. Because an agent is just a config file, it can be versioned in Git, pushed to any OCI registry and pulled to run on another machine. The project is written in Go, licensed Apache-2.0, and releases often: the 1.149.0 release in October 2026 added loading skills straight from public GitHub repositories and a dedicated evaluator backend for agent evals.

## What it does

- Agents and agent teams defined declaratively in YAML — versionable and shareable, no code required
- Multi-agent delegation: a root agent hands sub-tasks to specialised agents
- Any MCP server as a toolset — local, remote or Docker-based — plus built-in think, todo and memory tools
- Pluggable RAG with BM25, embeddings, hybrid search and reranking
- Provider-agnostic: OpenAI, Anthropic, Gemini, AWS Bedrock, Mistral, xAI and local models through Docker Model Runner
- Package agents as OCI artifacts: push to any registry and run them elsewhere with `docker agent run org/agent:tag`
- Skills loaded from public GitHub repositories, hooks, and an evals system with LLM-as-judge or a dedicated evaluator backend

## Getting started

Docker Desktop 4.63 or later already includes the `docker agent` plugin. Otherwise install it with Homebrew or a binary from the GitHub releases page. You need at least one model provider API key, or Docker Model Runner for local models.

1. Install the plugin

   Skip this step if you use Docker Desktop 4.63+.

```bash
brew install docker-agent
```

2. Set a model provider key

```bash
export OPENAI_API_KEY=sk-...        # or ANTHROPIC_API_KEY, GOOGLE_API_KEY, etc.
```

3. Run the default agent, or generate your own

```bash
# Run the default agent
docker agent run

# Generate a new agent interactively
docker agent new
```

4. Write an agent in YAML

   This agent from the README gets web search through the DuckDuckGo MCP server.

```yaml
agents:
  root:
    model: openai/gpt-5-mini
    description: A helpful AI assistant
    instruction: |
      You are a knowledgeable assistant that helps users with various tasks.
      Be helpful, accurate, and concise in your responses.
    toolsets:
      - type: mcp
        ref: docker:duckduckgo
```

5. Run your config, or one from a registry

```bash
# Run your own config
docker agent run agent.yaml

# Run from an OCI registry
docker agent run myorg/agent:tag
```

## When to use it

- Build a team of agents — for example a root agent that delegates research and writing to specialists — from one YAML file
- Give an agent real tools by attaching MCP servers that run as Docker containers
- Run agents on local models through Docker Model Runner instead of a cloud API
- Share a team's agents through a container registry, the same way you share images

## Version history

- 2026-10-07 v1.149.0: Skills can be loaded straight from public GitHub repositories, a dedicated evaluator judge backend joins LLM-as-judge, and evaluators now route through the models gateway, with OpenAI Decisions as a native evaluator.
