In the rapidly evolving landscape of AI, building and deploying AI agents has often required navigating a maze of complex frameworks, managing multiple API integrations, and wrestling with configuration files scattered across different services.
Docker has entered the agentic AI arena with cagent - an open-source, multi-agent runtime that brings the simplicity and portability Docker is known for to the world of AI agents. With over 1,000 commits and active development, cagent represents Docker's ambitious vision for democratizing AI agent development.
The Challenge of Building AI Agents
Creating AI agents that can interact with tools, process complex tasks, and collaborate with other agents can be a challenging and fragmented experience. Developers face several challenges including connecting to different LLM providers each with their own SDKs, managing tool integrations through various protocols, orchestrating multi-agent workflows, and handling the operational complexity of running agents in production environments.
Each provider - whether OpenAI, Anthropic, Google, or others - requires its own setup, authentication patterns, and API conventions. The Model Context Protocol (MCP) emerged as a standard for tool integration, but implementing MCP servers and connecting them to agents still requires significant boilerplate code.
Docker's cagent addresses these pain points by providing a unified runtime that abstracts provider differences while embracing open standards.
What Makes cagent Stand Out
What immediately drew me to cagent is its declarative, YAML-based approach to agent configuration. In a world where AI frameworks often require hundreds of lines of Python code to set up a basic agent, cagent lets you define sophisticated agents in a few lines of configuration.
The simplicity is reminiscent of Docker Compose - and that's no accident. Docker has applied the same philosophy of "infrastructure as code" to AI agents, making them portable, shareable, and reproducible.
The ability to push and pull agents to Docker Hub like container images is genuinely innovative. It means you can share your carefully crafted AI agent with a colleague using a single command, complete with all its configuration, tools, and system prompts.
Core Capabilities
- Multi-Provider Support: Connect to OpenAI, Anthropic Claude, Google Gemini, xAI Grok, Nebius, Mistral, and local models through Docker Model Runner - all with the same configuration syntax
- MCP Tool Integration: Native support for Model Context Protocol servers, enabling access to thousands of tools from the growing MCP ecosystem including Docker's curated MCP Catalog
- Multi-Agent Teams: Orchestrate hierarchical agent teams where agents can delegate tasks to sub-agents, enabling complex collaborative workflows
- RAG Support: Built-in Retrieval-Augmented Generation with support for local files and various embedding providers for grounding agents in your own data
- Docker Hub Distribution: Push and pull agent configurations as OCI artifacts, enabling version control and sharing through familiar Docker workflows
Quick Start with cagent
Getting started with cagent is straightforward. On macOS, you can install it via Homebrew, or download pre-built binaries for Linux and Windows from the GitHub releases page. Once installed, creating your first agent is as simple as writing a YAML file:
#!/usr/bin/env cagent run 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: filesystem - type: shell - type: mcpref: docker:duckduckgo # stdio transport - type: mcp
command: rust-mcp-filesystem # installed with `cargo install rust-mcp-filesystem`
args: ["--allow-write", "."]
tools: ["read_file", "write_file"] # Optional: specific tools only
env:
- "RUST_LOG=debug"
This minimal configuration creates an agent powered by OpenAI that can read and write files and execute shell commands. Running it is as simple as executing cagent run ./my-assistant.yaml, which launches a terminal-based chat interface. For non-interactive use cases, the exec command allows you to run agents with a single prompt, perfect for automation and scripting.
Architecture and Technology
cagent is written in Go 1.25, chosen for its excellent performance characteristics and ability to produce single-binary distributions without runtime dependencies. The codebase is thoughtfully organized into over 45 packages within the pkg directory, covering everything from agent runtime logic to TUI components built with Bubble Tea, the popular Go framework for terminal applications.
The project leverages several notable dependencies: anthropic-sdk-go and openai-go for provider integrations, the official MCP Go SDK for tool connectivity, go-git for repository operations, and SQLite for session persistence.
The architecture separates concerns cleanly - the runtime package handles the core agent execution loop, the model package abstracts provider differences, and the mcp package manages tool server connections. This separation enables the impressive provider flexibility where switching from OpenAI to Anthropic or a local model requires only changing a configuration value.
The MCP Ecosystem
One of cagent's most powerful features is its deep integration with the Model Context Protocol ecosystem. MCP has emerged as the standard for connecting AI agents to external tools and services, and cagent makes leveraging this ecosystem remarkably easy.
You can connect to MCP servers by specifying them in your agent configuration using the docker: prefix for servers from Docker's curated MCP Catalog, or by referencing containers directly.
For example, adding GitHub capabilities to your agent requires just a single line in the mcp configuration section. Docker's MCP Gateway provides a unified endpoint that can proxy requests to multiple MCP servers, simplifying the networking complexity of tool integration.
The MCP Toolkit in Docker Desktop offers a graphical interface for discovering and configuring MCP servers, making the ecosystem accessible even to developers new to the protocol.
Orchestrating Agent Collaboration
cagent truly shines in multi-agent scenarios. The dev-team example demonstrates a hierarchical team structure where a Product Manager agent coordinates with Designer and Full Stack Engineer sub-agents:
#!/usr/bin/env cagent run
models:
model:
provider: anthropic
model: claude-sonnet-4-0
max_tokens: 64000
agents:
root:
model: model
description: Product Manager - Leads the development team and coordinates iterations
instruction: |
You are the Product Manager leading a development team consisting of a designer, frontend engineer, full stack engineer, and QA tester.
.....
sub_agents: [designer, awesome_engineer]
toolsets:
- type: filesystem
- type: think
- type: todo
- type: memory
path: dev_memory.db
- type: mcp
ref: docker:context7
designer:
model: model
description: UI/UX Designer - Creates user interface designs and wireframes
instruction: |
You are a UI/UX Designer working on a development team. Your role is to create user-friendly, intuitive designs for each feature iteration.
.....
toolsets:
- type: filesystem
- type: think
- type: memory
path: dev_memory.db
- type: mcp
ref: docker:context7
awesome_engineer:
model: model
description: Awesome Engineer - Implements user interfaces based on designs
instruction: |
You are an Awesome Engineer responsible for implementing user interfaces based on the designer's specifications.
.....
toolsets:
- type: filesystem
- type: shell
- type: think
- type: memory
path: dev_memory.db
- type: mcp
ref: docker:context7
The root agent can delegate tasks to sub-agents, receiving their outputs and coordinating the overall workflow. This pattern mirrors how real development teams operate, with specialized roles collaborating toward common goals. Each agent can have its own model, tools, and system prompt, enabling sophisticated division of labor.
Practical Applications
The examples directory contains over 60 configurations demonstrating cagent's versatility. The basic examples show fundamental patterns like filesystem operations, shell command execution, and web browsing.
Advanced examples tackle scenarios like code review automation, technical writing, finance analysis, and research workflows. But the real power of cagent emerges when we explore its potential across development, creative, and executive domains.
Development Workflows
According to GitHub's research on AI code generation, 88% of developers reported feeling more productive when using AI assistance, with 87% spending less mental effort on repetitive tasks (GitHub, 2024).
Cagent takes this further by enabling autonomous, multi-step coding workflows. Amazon recently previewed "Kiro," an AI agent that can "code on its own for days" (TechCrunch, December 2025). With cagent's multi-agent team capabilities, you can configure similar autonomous workflows - a code generation agent, a review agent, and a testing agent working in concert through YAML configuration.
The bio example creates a personal assistant that can answer questions about you based on a biography file, while the github example integrates with GitHub's MCP server for repository operations. For DevOps automation, cagent's MCP integration enables agents that monitor CI/CD pipelines, auto-remediate failures, perform security scanning, and orchestrate containerized deployments.
The code-review example demonstrates how agents can analyze code for bugs, style issues, and security vulnerabilities - creating a multi-agent review pipeline where specialized agents handle different aspects of code quality.
Creative and Marketing Applications
The McKinsey "Superagency in the Workplace" report identifies sales and marketing as having the highest economic AI potential at 28% (McKinsey, January 2025). Cagent's multi-agent teams can power sophisticated content creation pipelines - imagine a Research Agent gathering market data, a Writer Agent drafting content, an Editor Agent refining tone and brand voice, and an SEO Agent optimizing for search visibility. Each agent operates with its own specialized system prompt and tools, yet collaborates seamlessly through cagent's hierarchical team structure.
Notion recently launched "agents for data analysis and task automation" (TechCrunch, September 2025), demonstrating the appetite for creative workflow automation. Cagent enables similar capabilities: campaign performance monitoring through MCP tool integration, audience segmentation analysis using RAG to process customer data, and personalized content recommendations.
The technical writing examples in the repository showcase how agents can maintain consistent documentation across large projects, while the finance analysis examples demonstrate data-driven creative reporting.
Executive and Strategic Applications
McKinsey's research reveals a striking paradox: 92% of companies plan to increase AI investments over the next three years, yet only 1% of leaders call their companies "mature" in AI deployment (McKinsey, 2025).
This maturity gap represents a significant opportunity for tools like cagent that lower the barrier to AI adoption. With cagent's RAG support, executives can deploy agents that synthesize intelligence across multiple data sources, generate executive summaries, and alert on anomalies and opportunities.
The McKinsey report notes that 94% of employees and 99% of C-suite executives have familiarity with generative AI, with millennials (ages 35-44) being the strongest AI advocates at 90% comfortable using AI at work. Cagent enables executive-focused applications including meeting preparation briefings that pull context from calendars and email, strategic decision support through multi-agent scenario modeling, and customer service oversight.
Wonderful raised $100 million to "put AI agents on the front lines of customer service" (TechCrunch, November 2025), and cagent's architecture supports similar enterprise-scale deployments with proper governance and auditability through its transparent YAML configurations.
Addressing Enterprise Concerns
McKinsey's research highlights that while 71% of employees trust their employers to deploy AI ethically, significant concerns remain: cybersecurity (51%), inaccuracies (50%), and privacy (43%) (McKinsey, 2025). Docker cagent addresses these concerns through its containerized architecture - agents run in isolated, sandboxed environments that limit blast radius.
The multi-provider flexibility allows organizations to choose models based on compliance requirements, whether that means running local models through Docker Model Runner for sensitive data or using enterprise-tier cloud providers with appropriate data processing agreements. The transparent, version-controlled YAML configurations make agent behavior auditable, a critical requirement for regulated industries.
Open Source and Community
cagent is developed in the open with an active community of contributors. The project has seen contributions from Docker employees and external developers alike, with over 1,000 pull requests merged since its inception. The CONTRIBUTING.md guide outlines how to get involved, from reporting issues to submitting code changes.
Development uses Task (a Go task runner) for build automation, with comprehensive end-to-end tests ensuring reliability. The rapid release cadence - currently at version 1.14.0 with multiple releases per week - demonstrates the project's momentum and Docker's commitment to rapid iteration based on user feedback.
Usage and License Terms
cagent is released under the Apache License 2.0, one of the most permissive open-source licenses available. This means you can freely use, modify, and distribute cagent in both personal and commercial projects.
You can incorporate it into proprietary software without being required to release your source code. The Apache 2.0 license also provides an express grant of patent rights from contributors to users, offering additional legal protections. This licensing choice aligns with Docker's historical commitment to open-source and ensures that cagent can be adopted widely across the industry without licensing concerns.
Future Potential and Impact
cagent represents Docker's bet that the future of AI development will mirror the containerization revolution - where portability, reproducibility, and ease of deployment matter as much as raw capabilities. By treating agents as artifacts that can be versioned, shared, and deployed through familiar Docker workflows, cagent lowers the barrier to entry for teams looking to incorporate agentic AI into their applications.
The integration with Docker's broader AI initiative - including Model Runner for local LLM execution and the MCP Catalog for tool discovery - positions cagent as part of a comprehensive platform play. As AI agents become more prevalent in software development workflows, having a standardized runtime that works across providers and environments will be increasingly valuable. The open-source nature ensures that the community can extend and adapt cagent for emerging use cases.
About Docker
Docker, Inc. is the company behind the Docker containerization platform that transformed how software is built, shipped, and run. Founded in 2013, Docker introduced the concept of lightweight containers that package applications with their dependencies, enabling consistent deployment across different environments.
Today, Docker Desktop is used by millions of developers worldwide, and Docker Hub hosts millions of container images. With cagent, Docker is extending its mission of simplifying developer workflows into the AI era, applying the same principles of portability and simplicity that made containers successful to the emerging world of AI agents. The company's Docker AI initiative encompasses Model Runner, MCP Gateway, Docker Compose for agents, and Gordon (an AI assistant integrated into Docker Desktop).
Start Building Agents Today
Docker's cagent brings a refreshing approach to AI agent development - one that prioritizes simplicity, portability, and developer experience without sacrificing capability. Whether you're building a simple chatbot, a sophisticated multi-agent team, or integrating AI capabilities into existing workflows, cagent provides a solid foundation that grows with your needs.
The YAML-based configuration, extensive provider support, and seamless MCP integration make it accessible to newcomers while remaining powerful enough for production deployments. With active development, strong community engagement, and Docker's backing, cagent is well-positioned to become a standard tool in the AI developer's toolkit. Visit the GitHub repository to explore the examples, try building your first agent, and join the growing community of developers shaping the future of agentic AI.
Docker cagent: The Open-Source Multi-Agent AI Runtime