The Problem

You have 3 features to build, one AI agent, and a deadline breathing down your neck. The agent works on Feature A... finishes... moves to Feature B... finishes... then Feature C. Each feature takes 10 minutes. That is 30 minutes of serial execution.

Now imagine: what if you could spin up 3 agents simultaneously, each working on a different feature in its own isolated terminal? All three finish in 10 minutes. Same work, one-third the wall-clock time.

That is exactly what CAO does.

The Supervisor-Worker Pattern

Think of an air traffic control tower. The controller does not fly the planes — it assigns runways, sequences takeoffs, and resolves conflicts. The pilots (agents) do the actual flying. CAO's supervisor works the same way: it reads your task, breaks it into sub-tasks, and delegates each one to a worker agent.

The supervisor never writes code directly. It thinks in terms of delegation — "worker-1 handles the API route, worker-2 writes the tests, worker-3 updates the docs" — then monitors their progress through an MCP-based message system. When all workers report done, the supervisor synthesizes results and reports back to you.

What Happens When You Type cao launch

Five concrete steps, from your terminal to a running agent:

Quick Start

Install CAO and launch your first orchestrated agent in under a minute:

# Install CAO
uv tool install cli-agent-orchestrator

# Start the server (leave running)
cao-server

# Launch a supervisor agent
cao launch --agents code_supervisor \
  --provider claude_code

Key Terms

Three Tools, Three Styles

CAO gives agents exactly three MCP tools for inter-agent communication. Each one creates a distinct interaction pattern between supervisor and worker, matching a real-world collaboration style.

Master these three and you understand everything about how CAO agents coordinate.

The Key Difference

# mcp_server/server.py (simplified)
worker_message = message + "[...reply to me with send_message]"
terminal_id, _ = _create_terminal(
    agent_profile=agent_profile,
    initial_message=worker_message,
    defer_init=True,
)
return {"success": True, "terminal_id": terminal_id, ...}

Match the Patterns

Drag each chip into the correct zone:

When to Use What

Real orchestration decisions come down to one question: does the supervisor need the result right now, or can it keep working? Pick the right tool for each scenario.

From Zero to Multi-Agent in 5 Minutes

Six commands take you from nothing installed to a fully running multi-agent session:

Anatomy of a Profile

Profiles are markdown files with YAML frontmatter. They live in a standard directory:

---
name: code_supervisor
description: Coding Supervisor Agent
provider: claude_code
role: supervisor
---
You are a supervisor. Delegate to
`developer` and `reviewer` profiles.

The Role System

Each role grants a specific set of tools. Choose the narrowest role that fits the agent's job.

Final Check

You now understand how CAO works — from the supervisor-worker pattern to the orchestration tools to hands-on usage. Go build something with multiple agents.