# CLI Agent Orchestrator

> Supervisor-and-worker multi-agent coordination across coding CLIs — handoffs over MCP.

[Canonical HTML page](https://top-mcps.com/mcp/cli-agent-orchestrator) · [server.json](https://top-mcps.com/mcp/cli-agent-orchestrator.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Paste under mcpServers. Fully quit and reopen Claude after editing.

```json
{
  "mcpServers": {
    "cli-agent-orchestrator": {
      "command": "uv",
      "args": [
        "tool",
        "install",
        "git+https://github.com/awslabs/cli-agent-orchestrator.git@main",
        "--upgrade"
      ]
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Run from your repo. Commit .mcp.json to share with your team.

```shell
claude mcp add cli-agent-orchestrator -- uv tool install git+https://github.com/awslabs/cli-agent-orchestrator.git@main --upgrade
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Reload window after editing.

```json
{
  "mcpServers": {
    "cli-agent-orchestrator": {
      "command": "uv",
      "args": [
        "tool",
        "install",
        "git+https://github.com/awslabs/cli-agent-orchestrator.git@main",
        "--upgrade"
      ]
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key (not "mcpServers").

```jsonc
{
  "servers": {
    "cli-agent-orchestrator": {
      "command": "uv",
      "args": [
        "tool",
        "install",
        "git+https://github.com/awslabs/cli-agent-orchestrator.git@main",
        "--upgrade"
      ]
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Open via Cascade → hammer icon → Configure.

```json
{
  "mcpServers": {
    "cli-agent-orchestrator": {
      "command": "uv",
      "args": [
        "tool",
        "install",
        "git+https://github.com/awslabs/cli-agent-orchestrator.git@main",
        "--upgrade"
      ]
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Open via the Cline sidebar → MCP Servers → Edit.

```json
{
  "mcpServers": {
    "cli-agent-orchestrator": {
      "command": "uv",
      "args": [
        "tool",
        "install",
        "git+https://github.com/awslabs/cli-agent-orchestrator.git@main",
        "--upgrade"
      ]
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue uses modelContextProtocolServers with a transport block.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "uv",
          "args": [
            "tool",
            "install",
            "git+https://github.com/awslabs/cli-agent-orchestrator.git@main",
            "--upgrade"
          ]
        }
      }
    ]
  }
}
```

### Codex CLI — `~/.codex/config.toml`

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

```shell
# ~/.codex/config.toml
[mcp_servers.cli-agent-orchestrator]
command = "uv"
args = [
  "tool",
  "install",
  "git+https://github.com/awslabs/cli-agent-orchestrator.git@main",
  "--upgrade",
]
```

### Zed — `~/.config/zed/settings.json`

Zed calls them "context_servers". Settings live-reload on save.

```jsonc
{
  "context_servers": {
    "cli-agent-orchestrator": {
      "command": {
        "path": "uv",
        "args": [
          "tool",
          "install",
          "git+https://github.com/awslabs/cli-agent-orchestrator.git@main",
          "--upgrade"
        ]
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Apps directory`

CLI Agent Orchestrator doesn't ship a hosted HTTPS endpoint today. ChatGPT supports remote MCP servers only — to use this server in ChatGPT you'll need to deploy it to a public HTTPS URL first (e.g. via Cloudflare Workers or Vercel) or wait for an official remote build.

```none

```

## At a glance

- **Maintainer:** AWS Labs
- **Transport:** stdio
- **Auth model:** None
- **Required secrets:** None
- **Supported clients:** Claude Code, Kiro CLI, Any MCP-compatible coding CLI
- **License:** Apache-2.0
- **Language:** Python
- **Latest version:** 2.2.0
- **Last verified:** 2026-06-22
- **GitHub stars:** 727 (fetched 2026-06-22T09:44:48.335Z)
- **Score:** 73/100 (rubric 2026-04 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/awslabs/cli-agent-orchestrator

## Tools & permissions

| Tool | Description | Args | Side effects |
|------|-------------|------|--------------|
| `handoff` | Synchronously delegate a task to another agent and wait for the result. | `target: string, task: string` | write |
| `assign` | Asynchronously assign a task to a worker agent. | `target: string, task: string` | write |
| `send_message` | Send a message to another agent in the session. | `target: string, message: string` | write |
| `list_sessions` | List active agent sessions. | `—` | read |

## Security & scope

- **Access scope:** read-write
- **Sandbox:** Each agent runs in an isolated tmux session on the local machine. The orchestrator coordinates them over MCP; the agents themselves hold whatever credentials their CLI is configured with.
- **Gotchas:**
  - Worker agents inherit the credentials and write access of the CLI they run — scope those before letting a supervisor dispatch unattended.
  - Some CLI integrations are experimental; do not assume every supported CLI is equally stable.
  - Parallel agents can race on a shared filesystem — keep each agent scoped to its own working directory.

## Quick answer

**What it does.** Runs a supervisor agent that decomposes work and dispatches subtasks to worker agents in isolated tmux sessions. Exposes MCP tools for synchronous handoff, asynchronous assignment, inter-agent messaging, and session lifecycle management.

**Best for:**
- Supervisor-worker multi-agent coding
- Parallelizing large builds across agents
- Coordinating multiple coding CLIs
- Isolated per-agent working sessions
- Scheduled / CI-driven agent runs

**Not for:**
- Single-agent tasks
- Environments without tmux
- Workflows needing a fully stable, non-experimental surface

## Description

CLI Agent Orchestrator (CAO) is an AWS Labs MCP server for running multiple AI coding agents in parallel under a supervisor-worker pattern. A supervisor agent decomposes a goal and hands subtasks to specialist agents, each running in its own isolated tmux session, and the agents communicate through MCP tools — handoff, assign, and message. It coordinates across different CLIs (Claude Code, Kiro CLI, and others) rather than locking you to one, which makes it the orchestration layer for teams that already live in multiple agent CLIs.

## Why it matters

Single-agent loops stall on large, parallelizable work. CAO is one of the few orchestration servers backed by a vendor org (AWS Labs) that coordinates real coding CLIs through MCP rather than reimplementing an agent runtime, and the isolated-session model keeps one agent's mistakes from corrupting another's working tree.

## Key features

- Supervisor-worker orchestration pattern
- Isolated tmux session per agent
- Cross-CLI coordination (Claude Code, Kiro, others)
- Handoff / assign / message MCP tools
- Session lifecycle management
- AWS Labs maintained

## FAQ

### Does it work with more than Claude Code?

Yes — CAO is built to coordinate multiple coding CLIs (Claude Code, Kiro CLI, and others). That cross-CLI coordination is its main differentiator from single-CLI orchestration servers.

### Is it production-ready?

The core supervisor-worker orchestration is usable for scheduled and CI-driven runs, but some integrations (notably OpenCode CLI) are marked experimental. Evaluate the specific CLI you intend to use.

### Why does it need tmux?

Each agent runs in its own isolated tmux session so one agent's working tree and process state stay separate from another's. Without tmux the isolation model does not apply.

## Changelog

- **2026-06-22** — Refreshed install snippets and fact sheet; verified for 2026.
- **2025-09-01** — Initial directory listing.