Rename cagent to Docker agent

content/get-started/workshop/10_what_next.md

@@ -35,9 +35,9 @@ ai-development:
 - title: MCP Toolkit
   description: Set up, manage, and run containerized MCP servers to power your AI agents.
   link: /ai/mcp-catalog-and-toolkit/toolkit/
-- title: Build AI agents with cagent
+- title: Build AI agents with Docker Agent
   description: Create teams of specialized AI agents that collaborate to solve complex problems.
-  link: /ai/cagent/
+  link: /ai/docker-agent/
 - title: Use AI models in Compose
   description: Define AI model dependencies in your Docker Compose applications.
   link: /compose/how-tos/model-runner/

content/guides/agentic-ai.md

@@ -13,7 +13,7 @@ params:
 >
 > This guide uses the familiar Docker Compose workflow to orchestrate agentic AI
 > applications. For a smoother development experience, check out [Docker
-> cagent](../manuals/ai/cagent/_index.md), a purpose-built agent runtime that
+> Docker Agent](../manuals/ai/docker-agent/_index.md), a purpose-built agent runtime that
 > simplifies running and managing AI agents.
 
 ## Introduction

content/guides/lab-cagent.md → content/guides/lab-docker-agent.md

@@ -1,48 +1,49 @@
 ---
-title: "Lab: Getting Started with cagent"
-linkTitle: "Lab: Getting Started with cagent"
+title: "Lab: Getting Started with Docker Agent"
+linkTitle: "Lab: Getting Started with Docker Agent"
 description: |
-  Build intelligent multi-agent teams with cagent and Docker in this hands-on
+  Build intelligent multi-agent teams with Docker Agent and Docker in this hands-on
   interactive lab.
 summary: |
   Hands-on lab: Create, share, and orchestrate intelligent AI agents using
-  cagent, MCP Toolkit, and Docker.
-keywords: AI, Docker, cagent, agents, multi-agent, MCP Toolkit, lab, labspace
+  Docker Agent, MCP Toolkit, and Docker.
+keywords: AI, Docker, docker agent, agents, multi-agent, MCP Toolkit, lab, labspace
 aliases:
   - /labs/docker-for-ai/cagent/
+  - /guides/lab-cagent/
 params:
   tags: [ai, labs]
   time: 20 minutes
   resource_links:
-    - title: cagent documentation
+    - title: Docker Agent documentation
       url: https://github.com/docker/cagent
     - title: Docker MCP Toolkit
       url: https://docs.docker.com/ai/mcp-catalog-and-toolkit/toolkit/
     - title: Labspace repository
       url: https://github.com/ajeetraina/labspace-cagent
 ---
 
-This lab walks you through building intelligent agents with cagent. You'll learn beginner
+This lab walks you through building intelligent agents with Docker Agent. You'll learn beginner
 agent concepts, then build sophisticated multi-agent teams that handle complex
 real-world tasks. Learn how to create, share, and orchestrate AI agents with
 Docker.
 
 ## What you'll learn
 
-- Create simple agents with cagent
+- Create simple agents with Docker Agent
 - Use built-in generic agentic tools for common tasks
 - Integrate MCP servers from the MCP Toolkit
 - Share agents using the Docker Registry
 - Build multi-agent systems for complex workflows
-- Use Docker Model Runner with cagent (preview)
+- Use Docker Model Runner with Docker Agent (preview)
 
 ## Modules
 
 | # | Module | Description |
 |---|--------|-------------|
-| 1 | Introduction | Overview of cagent and intelligent agent concepts |
-| 2 | Getting Started | Create your first agent with cagent |
-| 3 | Using Built-in Tools | Leverage the generic agentic tools in cagent |
+| 1 | Introduction | Overview of Docker Agent and intelligent agent concepts |
+| 2 | Getting Started | Create your first agent with Docker Agent |
+| 3 | Using Built-in Tools | Leverage the generic agentic tools in Docker Agent |
 | 4 | Using MCP | Integrate MCP servers from the MCP Toolkit |
 | 5 | Sharing Agents | Package and share agents via Docker Registry |
 | 6 | Introduction to Sub-agents | Build multi-agent systems with sub-agent orchestration |

content/manuals/_index.md

@@ -32,10 +32,10 @@ params:
     description: Run containers programmatically in your preferred programming language.
     icon: /icons/Testcontainers.svg
     link: /testcontainers/
-  - title: Cagent
+  - title: Docker Agent
     description: The open-source multi-agent solution to assist you in your tasks.
     icon: /icons/cagent.svg
-    link: /ai/cagent
+    link: /ai/docker-agent
   ai:
   - title: Ask Gordon
     description: Streamline your workflow and get the most out of the Docker ecosystem with your personal AI assistant.

content/manuals/ai/cagent/_index.md → content/manuals/ai/docker-agent/_index.md

@@ -1,27 +1,30 @@
 ---
-title: cagent
-description: cagent lets you build, orchestrate, and share AI agents that work together as a team.
+title: Docker Agent
+description: Docker Agent lets you build, orchestrate, and share AI agents that work together as a team.
 weight: 60
+aliases:
+  - /ai/cagent/
+  - /manuals/ai/cagent/
 params:
   sidebar:
     group: Open source
     badge:
       color: violet
       text: Experimental
-keywords: [ai, agent, cagent]
+keywords: [ai, agent, docker agent, cagent]
 ---
 
-{{< summary-bar feature_name="cagent" >}}
+{{< summary-bar feature_name="Docker Agent" >}}
 
-[cagent](https://github.com/docker/cagent) is an open source tool for building
+[Docker Agent](https://github.com/docker/cagent) is an open source tool for building
 teams of specialized AI agents. Instead of prompting one generalist model, you
 define agents with specific roles and instructions that collaborate to solve
 problems. Run these agent teams from your terminal using any LLM provider.
 
 ## Why agent teams
 
 One agent handling complex work means constant context-switching. Split the work
-across focused agents instead - each handles what it's best at. cagent manages
+across focused agents instead - each handles what it's best at. Docker Agent manages
 the coordination.
 
 Here's a two-agent team that debugs problems:
@@ -58,17 +61,19 @@ its specialty.
 
 ## Installation
 
-cagent is included in Docker Desktop 4.49 and later.
+Docker Agent is included in Docker Desktop 4.63 and later. In Docker Desktop versions 4.49 through 4.62, this feature was called cagent.
 
 For Docker Engine users or custom installations:
 
 - **Homebrew**: `brew install cagent`
 - **Winget**: `winget install Docker.Cagent`
 - **Pre-built binaries**: [GitHub
   releases](https://github.com/docker/cagent/releases)
-- **From source**: See the [cagent
+- **From source**: See the [Docker Agent
   repository](https://github.com/docker/cagent?tab=readme-ov-file#build-from-source)
 
+The `docker-agent` binary should be copied to `~/.docker/cli-plugins` and then can be used with the `docker agent` command. Alternatively, it can be used as a standalone binary.
+
 ## Get started
 
 Try the bug analyzer team:
@@ -86,7 +91,7 @@ Try the bug analyzer team:
 3. Run your agent team:
 
    ```console
-   $ cagent run debugger.yaml
+   $ docker agent run debugger.yaml
    ```
 
 You'll see a prompt where you can describe bugs or paste error messages. The
@@ -138,8 +143,8 @@ Agent configurations are packaged as OCI artifacts. Push and pull them like
 container images:
 
 ```console
-$ cagent push ./debugger.yaml myusername/debugger
-$ cagent pull myusername/debugger
+$ docker agent push ./debugger.yaml myusername/debugger
+$ docker agent pull myusername/debugger
 ```
 
 Use Docker Hub or any OCI-compatible registry. Pushing creates the repository if
@@ -149,11 +154,11 @@ it doesn't exist yet.
 
 - Follow the [tutorial](./tutorial.md) to build your first coding agent
 - Learn [best practices](./best-practices.md) for building effective agents
-- Integrate cagent with your [editor](./integrations/acp.md) or use agents as
+- Integrate Docker Agent with your [editor](./integrations/acp.md) or use agents as
   [tools in MCP clients](./integrations/mcp.md)
-- Browse example agent configurations in the [cagent
+- Browse example agent configurations in the [Docker Agent
   repository](https://github.com/docker/cagent/tree/main/examples)
-- Use `cagent new` to generate agent teams with AI <!-- TODO: link to some page
+- Use `docker agent new` to generate agent teams with AI <!-- TODO: link to some page
   where we explain this, probably a CLI reference? -->
 - Connect agents to external tools via the [Docker MCP
   Gateway](/manuals/ai/mcp-catalog-and-toolkit/mcp-gateway.md)

content/manuals/ai/cagent/best-practices.md → content/manuals/ai/docker-agent/best-practices.md

@@ -1,11 +1,11 @@
 ---
 title: Best practices
-description: Patterns and techniques for building effective cagent agents
-keywords: [cagent, best practices, patterns, agent design, optimization]
+description: Patterns and techniques for building effective agents
+keywords: [docker agent, best practices, patterns, agent design, optimization]
 weight: 40
 ---
 
-Patterns you learn from building and running cagent agents. These aren't
+Patterns you learn from building and running agents with Docker Agent. These aren't
 features or configuration options - they're approaches that work well in
 practice.
 

content/manuals/ai/cagent/evals.md → content/manuals/ai/docker-agent/evals.md

@@ -1,7 +1,7 @@
 ---
 title: Evals
 description: Test your agents with saved conversations
-keywords: [cagent, evaluations, testing, evals]
+keywords: [docker agent, evaluations, testing, evals]
 weight: 80
 ---
 
@@ -12,7 +12,7 @@ tell you if behavior changed, not whether it's right or wrong.
 
 ## What are evals
 
-An eval is a saved conversation you can replay. When you run evals, cagent
+An eval is a saved conversation you can replay. When you run evals, Docker Agent
 replays the user messages and compares the new responses against the original
 saved conversation. High scores mean the agent behaved similarly; low scores
 mean behavior changed.
@@ -48,7 +48,7 @@ bad.
 Save a conversation from an interactive session:
 
 ```console
-$ cagent run ./agent.yaml
+$ docker agent run ./agent.yaml
 ```
 
 Have a conversation with your agent, then save it as an eval:
@@ -66,25 +66,25 @@ directory. You can organize eval files in subdirectories if needed.
 Run all evals in the default directory:
 
 ```console
-$ cagent eval ./agent.yaml
+$ docker agent eval ./agent.yaml
 ```
 
 Use a custom eval directory:
 
 ```console
-$ cagent eval ./agent.yaml ./my-evals
+$ docker agent eval ./agent.yaml ./my-evals
 ```
 
 Run evals against an agent from a registry:
 
 ```console
-$ cagent eval agentcatalog/myagent
+$ docker agent eval agentcatalog/myagent
 ```
 
 Example output:
 
 ```console
-$ cagent eval ./agent.yaml
+$ docker agent eval ./agent.yaml
 --- 0
 First message: tell me something interesting about kil
 Eval file: c7e556c5-dae5-4898-a38c-73cc8e0e6abe
@@ -96,7 +96,7 @@ Output tokens: 177
 
 ## Understanding results
 
-For each eval, cagent shows:
+For each eval, Docker Agent shows:
 
 - **First message** - The initial user message from the saved conversation
 - **Eval file** - The UUID of the eval file being run
@@ -156,7 +156,7 @@ see what shifted.
 
 ## What's next
 
-- Check the [CLI reference](reference/cli.md#eval) for all `cagent eval`
+- Check the [CLI reference](reference/cli.md#eval) for all `docker agent eval`
   options
 - Learn [best practices](best-practices.md) for building effective agents
 - Review [example configurations](https://github.com/docker/cagent/tree/main/examples)

content/manuals/ai/cagent/integrations/_index.md → content/manuals/ai/docker-agent/integrations/_index.md

@@ -1,7 +1,7 @@
 ---
 title: Integrations
-description: Connect cagent agents to editors, MCP clients, and other agents
-keywords: [cagent, integration, acp, mcp, a2a, editor, protocol]
+description: Connect agents to editors, MCP clients, and other agents
+keywords: [docker agent, integration, acp, mcp, a2a, editor, protocol]
 weight: 60
 ---
 
@@ -12,7 +12,7 @@ want to use them. Each integration type serves a specific purpose.
 
 ### ACP - Editor integration
 
-Run cagent agents directly in your editor (Neovim, Zed). The agent sees your
+Run agents directly in your editor (Neovim, Zed). The agent sees your
 editor's file context and can read and modify files through the editor's
 interface. Use ACP when you want an AI coding assistant embedded in your
 editor.
@@ -21,7 +21,7 @@ See [ACP integration](./acp.md) for setup instructions.
 
 ### MCP - Tool integration
 
-Expose cagent agents as tools in MCP clients like Claude Desktop or Claude
+Expose agents as tools in MCP clients like Claude Desktop or Claude
 Code. Your agents appear in the client's tool list, and the client can call
 them when needed. Use MCP when you want Claude Desktop (or another MCP client)
 to have access to your specialized agents.
@@ -30,7 +30,7 @@ See [MCP integration](./mcp.md) for setup instructions.
 
 ### A2A - Agent-to-agent communication
 
-Run cagent agents as HTTP servers that other agents or systems can call using
+Run agents as HTTP servers that other agents or systems can call using
 the Agent-to-Agent protocol. Your agent becomes a service that other systems
 can discover and invoke over the network. Use A2A when you want to build
 multi-agent systems or expose your agent as an HTTP service.

content/manuals/ai/cagent/integrations/a2a.md → content/manuals/ai/docker-agent/integrations/a2a.md

@@ -1,12 +1,12 @@
 ---
 title: A2A mode
 linkTitle: A2A
-description: Expose cagent agents via the Agent-to-Agent protocol
-keywords: [cagent, a2a, agent-to-agent, multi-agent, protocol]
+description: Expose agents via the Agent-to-Agent protocol
+keywords: [docker agent, a2a, agent-to-agent, multi-agent, protocol]
 weight: 40
 ---
 
-A2A mode runs your cagent agent as an HTTP server that other systems can call
+A2A mode runs your agent as an HTTP server that other systems can call
 using the Agent-to-Agent protocol. This lets you expose your agent as a service
 that other agents or applications can discover and invoke over the network.
 
@@ -29,7 +29,7 @@ Before starting an A2A server, you need:
 Basic usage:
 
 ```console
-$ cagent a2a ./agent.yaml
+$ docker agent serve a2a ./agent.yaml
 ```
 
 Your agent is now accessible via HTTP. Other A2A systems can discover your
@@ -38,19 +38,19 @@ agent's capabilities and call it.
 Custom port:
 
 ```console
-$ cagent a2a ./agent.yaml --port 8080
+$ docker agent serve a2a ./agent.yaml --port 8080
 ```
 
 Specific agent in a team:
 
 ```console
-$ cagent a2a ./agent.yaml --agent engineer
+$ docker agent serve a2a ./agent.yaml --agent engineer
 ```
 
 From OCI registry:
 
 ```console
-$ cagent a2a agentcatalog/pirate --port 9000
+$ docker agent serve a2a agentcatalog/pirate --port 9000
 ```
 
 ## HTTP endpoints
@@ -142,7 +142,7 @@ Here's a concrete scenario where A2A is useful. You have two agents:
 Run the specialist as an A2A server:
 
 ```console
-$ cagent a2a ./code-reviewer.yaml --port 8080
+$ docker agent serve a2a ./code-reviewer.yaml --port 8080
 Listening on 127.0.0.1:8080
 ```
 
@@ -198,7 +198,7 @@ agents:
 
 ## What's next
 
-- Review the [CLI reference](../reference/cli.md#a2a) for all `cagent a2a`
+- Review the [CLI reference](../reference/cli.md#a2a) for all `docker agent serve a2a`
   options
 - Learn about [MCP mode](./mcp.md) to expose agents as tools in MCP clients
 - Learn about [ACP mode](./acp.md) for editor integration