Claude Code launches Agent Team mode: a team of AI agents instead of one

Claude Code has introduced an experimental Agent Team mode. Instead of running a single agent in the terminal, you can launch a whole team of independent participants that work in parallel and message each other, without the coordinator being involved in every step.

How Agent Team differs from subagents

In the classic subagent mode, Claude Code works hierarchically: one main agent calls helper agents as tools, waits for their reply and only then continues. That is useful, but fundamentally linear: the coordinator sits at the center of every operation, and everything passes through its context.

Agent Team changes the architecture. One session becomes the coordinator (team lead), and the others are independent teammates, each with its own context. Every agent has its own conversation history and workspace, and they do not share context with one another. Participants communicate through a structured internal channel: agents exchange messages rather than hand over control in turn. The task list is shared, and the agents work through it on their own as they go.

Technically, each teammate is a separate process with an isolated context. It receives tasks through an internal protocol rather than through a standard user prompt.

How to enable it and what you need

The mode is marked experimental and is not part of the standard build. Requirements:

• Claude Code version 2.1.32 or later: the mode first appeared in exactly this release
• a dedicated environment variable: its exact name is given in Anthropic's official documentation
• readiness for instability: the interface and behavior of the mode may change between versions without warning

Once activated, the terminal offers several display modes: you can watch the whole team at once or switch between individual agents. Hotkeys let you jump quickly to a given participant, view the conversation inside the team and track who has taken which task.

The author of the write-up verified every flag and command against an installed 2.1.32 binary. The material contains no guesses, only what works in the current build.

"Agent

Team lets multiple agents work in parallel on related tasks, communicating through structured messages," from the official Claude Code documentation.

Where the mode actually saves time

Agent Team shines in tasks that need parallelism and independent viewpoints at the same time:

• Cross-review of code: several agents look at one PR from different angles without influencing each other's context
• Bug hunting in a large codebase: agents split files and modules, speeding up a full sweep without the risk of missing something
• Comparing architectural approaches: each agent develops its own implementation, and the coordinator compares the results without bias
• Refactoring independent modules: parallel work avoids the context conflicts that arise with sequential subagent use

The key condition is that tasks must be independent enough that agents do not block each other over files or resources. When that holds, execution speed grows several-fold.

When the mode only gets in the way

Agent Team is not a universal solution. Several independent contexts mean several token meters running in parallel. For simple tasks such as "add a method to a class" or "fix one obvious bug," the mode is overkill and noticeably more expensive than a regular subagent.

Coordination through the internal channel adds overhead, in both tokens and processing time. If a task is linear, does not benefit from parallelism or requires a single context for decisions, launching a team will only slow the work down and inflate the final bill.

What this means

Agent Team turns Claude Code from a single developer's tool into a platform for a parallel AI team. For complex tasks such as review, broad code coverage and comparing approaches, it is a tangible expansion of capabilities.

The mode is experimental, and Anthropic explicitly warns that you should not yet count on API stability. Even so, it is already one of the most interesting experiments in the developer toolkit.