Agent Teams

Claude Code can now coordinate multiple independent agents that work together as a team — communicating directly with each other, claiming tasks from a shared list, and debating approaches in parallel. Released alongside Opus 4.6 in February 2026, Agent Teams is an experimental feature that goes far beyond subagents.

Teams vs. Subagents

If you have used Multi-Agent Workflows, you already know subagents. Agent Teams builds on that concept but changes the coordination model entirely.

How It Works

A team has three components:

1. Team Lead — your main Claude Code session. It spawns teammates, assigns initial tasks, and synthesizes results at the end.
2. Teammates — separate Claude Code instances, each with their own context window. They load your CLAUDE.md, MCP servers, and skills automatically.
3. Shared Task List — a centralized set of work items that teammates claim and complete, with dependency tracking that auto-unblocks tasks as prerequisites finish.

Team Lead
  ├── Teammate 1 (frontend)  ←→  Teammate 2 (backend)
  │       ↕                           ↕
  └── Teammate 3 (tests)     ←→  Teammate 4 (docs)

  Shared Task List: [task1 ✓] [task2 ⏳] [task3 🔒 blocked] [task4 ○]

The key difference from subagents: teammates talk to each other, not just to the lead. This peer-to-peer messaging enables real collaboration — agents can challenge each other's assumptions, share discoveries, and coordinate without bottlenecking through a single orchestrator.

Enabling Agent Teams

Agent Teams is experimental. Enable it by setting an environment variable or updating your settings.json.

Environment variable:

export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

Or in ~/.claude/settings.json:

{
  "env": {
    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
  }
}

Starting a Team

Once enabled, just ask Claude in natural language:

> Create an agent team to refactor the authentication system.
  One teammate on the API layer, one on the frontend hooks,
  one on writing tests.

Claude will spawn teammates with distinct roles, create a shared task list, and let them work in parallel. You can also be more specific:

> Create a team with 4 teammates using Sonnet for each.
  Investigate why checkout is failing — have each teammate
  test a different hypothesis.

Display Modes

Configure how teammates appear in your terminal via settings.json:

{
  "teammateMode": "in-process"
}

With in-process mode, press Shift+Up and Shift+Down to switch between teammates and send messages directly to a specific agent.

Delegate Mode

By default, the team lead can still write code itself. If you want it to act purely as a coordinator — only spawning teammates, managing tasks, and synthesizing results — enable delegate mode:

> Create a team in delegate mode to implement the new dashboard.

This prevents the lead from implementing anything directly, keeping it focused on orchestration.

When to Use Teams

Agent Teams work best for tasks with natural parallelism and where multiple perspectives add value.

Great use cases:

• Parallel code review — one teammate checks security, another checks performance, a third checks test coverage. Each applies a different lens to the same code.
• Debugging with competing hypotheses — teammates each investigate a different theory and debate findings. Reduces the anchoring bias that a single agent gets stuck on.
• New features with separate modules — teammates each own a distinct piece (API, UI, tests) without stepping on each other.
• Large refactors — break work by domain or by file group and let teammates execute in parallel.
• Research and exploration — teammates investigate different aspects of a codebase simultaneously, then share and challenge findings.

When to skip teams:

• Sequential tasks with many dependencies (single session is more efficient)
• Same-file edits (leads to overwrites and conflicts)
• Small tasks where coordination overhead exceeds the benefit
• Routine single-file changes

The C Compiler Demo

Anthropic demonstrated Agent Teams by building a Rust-based C compiler from scratch:

• 16 parallel agents working for 2 weeks
• ~2,000 Claude Code sessions spawned
• 100,000 lines of code generated
• Compiled Linux 6.9 across x86, ARM, and RISC-V
• 99% GCC test compatibility

The agents coordinated through Git, using text file locks to prevent conflicts. Each agent tackled independent compiler components without context pollution from other streams.

Current Limitations

Agent Teams is experimental — expect rough edges:

• One team per session (no nested teams)
• No session resumption with in-process teammates
• Lead role is fixed (cannot transfer leadership)
• Task status can lag (incomplete task marking)
• Shutdown can be slow
• Split panes require tmux or iTerm2 (not VS Code integrated terminal)
• Higher token cost than single-session workflows

Quick Reference

Agent Teams represent the next step in agentic coding — from a single assistant to a coordinated squad. The feature is experimental, so expect it to evolve, but the core pattern of parallel agents with peer-to-peer communication is already effective for complex, multi-faceted tasks.