amux vs Claude Code Agent Teams

Both run parallel Claude Code sessions. Agent Teams fans out within a single task. amux operates a long-lived fleet. Different scopes, different use cases.

Last updated: July 2026

What each tool is built for

Claude Code Agent Teams is an experimental Anthropic feature introduced in Claude Code v2.1.32. Enabled with the environment variable CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1, it lets a parent Claude Code session spawn child sub-agents and delegate portions of a task to them. Each child runs in an isolated git worktree, works its piece of the problem, and reports results back to the parent. The coordination model is hierarchical: one parent, N children, all sharing the same task context originating from the parent session. As of July 2026, Agent Teams is not default-enabled — it requires the experimental flag and a recent Claude Code version. There is no external dashboard, no mobile interface, and no self-healing if the parent session crashes or the context window fills up.

amux (304 GitHub stars, MIT license) is the open-source control plane for running an AI engineering team from a single dashboard or your phone. It launches, monitors, and self-heals dozens of parallel Claude Code, OpenAI Codex CLI, or Gemini CLI sessions headlessly in tmux — each session fully independent, not parent/child. The web dashboard streams live terminal output from every session via Server-Sent Events. The iOS app gives you remote monitoring and control from anywhere. A built-in kanban board lets agents atomically claim tasks so no two sessions ever duplicate work. The self-healing watchdog handles context exhaustion, crashes, and stuck prompts automatically, enabling true overnight unattended operation. Install via brew install mixpeek/amux/amux or pipx install amux. Single Python file, zero external dependencies — github.com/mixpeek/amux.

The core difference: sub-task fan-out vs long-lived fleet

Claude Code Agent Teams solves a specific decomposition problem: you have one big task and you want Claude to break it into parallel work streams. The parent session owns the problem, divides it, spawns children into git worktrees, waits for results, and synthesizes them. This is a tightly-coupled model — the entire operation lives inside a single Claude Code session tree. If the parent crashes, children may be orphaned. If the parent's context window overflows, the whole coordination layer stalls. There is no shared task queue, no persistent board, and no way to hand off work to a different runtime like Codex CLI or Gemini CLI. The scope is intentionally narrow: fan out within one task, collect results, move on.

amux is built for a different scope: a persistent fleet of independent agents running different tasks across different projects, potentially overnight, potentially from multiple AI runtimes. Sessions are not parent/child — each one is an autonomous worker that claims the next available task from a shared SQLite kanban board using an atomic compare-and-swap operation. No two agents can claim the same task. Sessions survive independently: if one crashes, the watchdog restarts it; if its context fills, it is auto-compacted and resumed. The fleet runs whether or not you are at your desk. You monitor from your phone. When all tasks are done, the board is empty and every session is idle — no parent to coordinate, no hierarchy to maintain.

These are not competing tools — they operate at different scopes. Agent Teams is a sub-task fan-out primitive inside Claude Code. amux is fleet infrastructure for running many independent Claude Code (and other) sessions at scale with full observability. The two can coexist: an amux-managed Claude Code session can use Agent Teams internally for a decomposition step while amux provides the outer lifecycle, dashboard, and recovery.

How Claude Code Agent Teams works

Agent Teams is built on Claude Code's existing sub-agent infrastructure. When you set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 and run Claude Code v2.1.32+, the parent session gains the ability to spawn child agents as first-class Claude Code processes. Each child is given an isolated git worktree — a lightweight copy of the repository at a specific branch or commit — so child agents can make changes without conflicting with each other at the filesystem level. The parent orchestrates the fan-out: it decides how to decompose the work, which child gets which subtask, and when to collect and merge results.

The coordination protocol is handled entirely within the Claude Code process tree. The parent sends task instructions to each child, receives completion signals and outputs, and synthesizes the combined result. This is analogous to a map-reduce step within a single Claude Code invocation. Children report back to the parent — there is no external message queue, no shared database, and no persistence layer outside the Claude Code session itself. The entire coordination state lives in the parent's context window and process memory.

This design makes Agent Teams easy to adopt — no extra infrastructure, no new tooling, just an env var and a sufficiently recent version of Claude Code. The trade-off is that everything is coupled to the parent session's lifecycle. If the parent is interrupted, the children have no coordination layer to reconnect to. There is no web dashboard, no mobile interface, no persistent task log, and no way to add non-Claude-Code runtimes to the mix. It is purpose-built for tightly-bounded fan-out within one coding task, not for operating a fleet of independent agents across many projects over many hours.

Feature comparison

When to use Agent Teams

• Tightly-coupled parallel subtask decomposition. You have a single large coding task — implement a feature, refactor a module, run a cross-file analysis — and want Claude to break it into parallel work streams, execute them in isolated git worktrees, and synthesize the result. Agent Teams is designed exactly for this: one parent, N children, one goal.
• You are already running Claude Code and want parallelism with zero additional tooling. No extra install, no server, no dashboard. Set one env var, upgrade Claude Code, and your existing session gains sub-agent fan-out capability. If your use case is a single tightly-bounded task and you are present to monitor it, Agent Teams is the lowest-friction path to parallelism.
• Short-lived, supervised fan-out where context coupling matters. Agent Teams preserves the parent's full context across all children. If the subtasks share substantial context — the same codebase understanding, the same requirements doc, the same session history — Agent Teams passes that context through the parent naturally. This is more efficient than spinning up N independent sessions that must each read the same context from scratch.

When to use amux

• Running 10–50 parallel agents overnight while you sleep. Queue work before bed, agents claim tasks from the shared board, work in parallel through the night, and you review completed branches in the morning from your phone. Agent Teams has no fleet model — if the parent session dies overnight, the whole coordination layer is lost. amux's watchdog keeps the fleet alive and productive without any human at the keyboard. See how to run 10+ agents in parallel.
• Long-lived sessions that must survive context overflow and crashes. The self-healing watchdog detects context overflow and automatically compacts and resumes the session. If an agent crashes, it is restarted and its pending message is replayed. Stuck prompts are unstuck. None of this is available with Agent Teams — if the parent session hits its context limit or crashes, the fan-out is over.
• Fleet observability: watching all agents simultaneously from a web dashboard. The amux dashboard streams live terminal output from every session via Server-Sent Events. You can peek at any agent's output, send it a steering message, or check the board — all from a browser or the iOS app. Agent Teams offers no monitoring UI beyond the Claude Code CLI itself.
• Multi-runtime fleets mixing Claude Code, Codex CLI, and Gemini CLI. amux treats any CLI-driven AI runtime as a session. You can run Claude Code sessions alongside Codex CLI sessions and Gemini CLI sessions in the same fleet, with shared board and messaging. Agent Teams is Claude Code only.
• Remote monitoring and steering from your phone. The iOS app and installable PWA let you inspect live terminal output, see which tasks are claimed on the board, send messages to any agent, approve quality gates, and manage the fleet from your iPhone. Agent Teams has no mobile story.
• Business operations alongside coding agents. amux includes Gmail API email, CRM contacts, a scheduler, notes, and browser automation in the same control plane as your coding sessions. Teams use it for customer support agents, market research, automated reporting, and CI orchestration alongside parallel coding work. This goes well beyond what Agent Teams is designed to handle.

Why not both? Agent Teams inside an amux-managed session

Agent Teams and amux target different scopes — and they compose naturally. Agent Teams handles sub-task fan-out within a single Claude Code session. amux handles fleet-level operation across many independent sessions. These layers do not conflict.

Consider a typical overnight batch run. You load 20 tasks onto the amux board. Ten independent Claude Code sessions claim tasks and start working. For a particularly complex task — say, a large refactor that spans three subsystems — the Claude Code session that claimed it can use Agent Teams internally to spin up child agents on isolated worktrees, collect their results, and produce the final merged output. amux sees this as one session working on one task. When the session finishes and marks the board item done, the next session claims the next task. The two layers are orthogonal: Agent Teams for the fan-out within a task, amux for the lifecycle, observability, and fleet coordination across tasks.

The practical answer is: start with Agent Teams if your problem is "this one task is too big for one context window." Start with amux if your problem is "I have 20 tasks across 5 repos and I want a fleet of agents working on them all night while I sleep." Once both problems exist, you likely need both layers.

Use case decision guide

Frequently Asked Questions

What is Claude Code Agent Teams?

Claude Code Agent Teams is an experimental Anthropic feature (enabled via the environment variable CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1, requires Claude Code v2.1.32+) that lets a parent Claude Code session spawn and coordinate child sub-agents using git worktrees for branch isolation. Each child agent works on its own worktree and reports results back to the parent. As of July 2026 it is not default-enabled and is still marked experimental.

Can I use Claude Code Agent Teams and amux together?

Yes — they operate at different scopes. Agent Teams handles sub-task fan-out within a single Claude Code session, while amux manages the fleet of independent top-level sessions and provides the dashboard, self-healing, mobile access, kanban, and scheduling layer on top. You can use Agent Teams for tightly-coupled decomposition inside an amux-managed session and still benefit from amux's observability and self-healing across the whole fleet.

Does amux replace Claude Code Agent Teams?

No. amux and Agent Teams solve different problems at different scopes. Agent Teams is a sub-agent fan-out mechanism built into Claude Code for tightly-coupled parallel work within a single parent session. amux is a fleet-level control plane for long-running, independent sessions across many projects, with a web dashboard, self-healing watchdog, mobile app, and support for Claude Code, Codex CLI, and Gemini CLI side by side.

How does amux handle agent coordination compared to Agent Teams?

Agent Teams coordinates via a parent Claude Code session: the parent spawns children, delegates tasks, and collects results — all within one Claude Code process tree. amux coordinates via a shared SQLite kanban board with atomic compare-and-swap claiming: any independent session can claim the next todo item without the risk of two agents duplicating the same task. amux also supports inter-session messaging via a REST API, scheduled tasks, and board-level quality gates.

Is Claude Code Agent Teams free?

The Agent Teams feature itself is free and ships with Claude Code (v2.1.32+), but you still pay Anthropic API token costs for every sub-agent spawned. Each child agent consumes tokens independently, so a fan-out of 5 sub-agents may multiply your token spend significantly depending on context sizes. amux similarly has no separate fee beyond the underlying API provider costs, and its open-source self-hosted tier is free.

Quick start with amux

# Install via Homebrew (recommended on macOS)
brew install mixpeek/amux/amux

# Or via PyPI
pipx install amux

# Or zero-install trial (no install needed)
uvx amux serve

# Register a project and launch the dashboard
amux register myproject --dir ~/Dev/myproject
amux serve  # → https://localhost:8822

See the getting started guide for a full walkthrough, how to run 10+ agents in parallel for fleet operations, and the quality gates guide for human-in-the-loop checkpoints at fleet scale. If you are already experimenting with Agent Teams for sub-task fan-out, amux adds the outer fleet lifecycle layer — dashboard, self-healing, mobile access, multi-runtime support — without conflicting with what Agent Teams does inside a single session.

See also

• All amux comparisons
• amux vs Claude Managed Agents
• amux vs Cursor
• amux vs Cline (Roo Code)
• amux vs OpenAI Codex CLI
• Best AI agent multiplexers in 2026
• Getting started with amux
• Running 10+ agents in parallel
• AI agent quality gates
• Mobile PWA and iOS app

brew install mixpeek/amux/amux
amux register myproject --dir ~/Dev/myproject
amux serve  # → https://localhost:8822