What is the Claude Code Swarm feature? Agent Teams, explained

Alongside the release of Claude Opus 4.6, Anthropic has officially announced one of the most anticipated features in Claude Code: Swarm mode - also known as Claude Code agent teams. What was once a hidden, feature-flagged capability is now available to everyone - and it fundamentally changes how we think about AI-assisted development.

Instead of talking to a single AI coder, you're now talking to a team lead who coordinates an entire agent team.

The discovery story

Here's a fun bit of context: the swarm feature was actually discovered before Anthropic announced it. Back in December 2025, developers started noticing hints of something bigger hiding in Claude Code's source.

I was the first to break this story, back on December 18, 2025. The method? Delightfully meta - I used Claude Code to read Claude Code's own source. Running strings commands on the binary revealed a fully-implemented orchestration layer called TeammateTool with 13 distinct operations for spawning, managing, and coordinating multiple AI agents.

Mike Kelly later packaged these discoveries into claude-sneakpeek, letting developers access the feature before the official release. But now, with today's announcement, everyone can use it natively.

What is Claude Code Swarm? Understanding agent teams

Swarm mode - or what Anthropic calls Claude Code agent teams - transforms Claude Code from a single AI assistant into a multi-agent orchestration system. The core insight is simple but powerful: instead of one Claude instance struggling with a massive codebase and running out of context, you get an agent team of specialists working in parallel.

Here's how it works:

1. You talk to a team lead - The lead agent doesn't write code itself. It plans, delegates, and synthesizes.

2. The lead spawns specialists - When you approve a plan, the lead enters "delegation mode" and creates agents for specific roles: frontend, backend, testing, documentation, architecture.

3. Agents work in parallel - Each specialist gets a fresh context window focused on their task. They share a task board with dependencies and coordinate via inter-agent messaging using @mentions.

4. Results flow back - Workers complete their tasks, mark them done, and report back to the lead. The lead synthesizes everything into a cohesive result.

You: "Build a user authentication system with OAuth, tests, and docs"

[Team Lead]
"I'll create a plan and spawn specialists for this..."

[Plan Approved - Delegation Mode]
├── auth-backend: Implementing OAuth provider integration
├── auth-frontend: Building login/logout UI components
├── test-agent: Writing integration tests for auth flow
└── docs-agent: Documenting API endpoints and usage

[Parallel Execution]
All agents work simultaneously, coordinating via task board...

[Synthesis]
"Authentication system complete. Here's what each specialist delivered..."

How it actually works

Under the hood, swarm mode uses a sophisticated coordination system:

TeammateTool operations

The orchestration layer exposes 13 operations organized into functional groups:

Team lifecycle:

• spawnTeam - Create a new team with a task list
• discoverTeams - Find available teams to join
• cleanup - Remove team resources when done

Join workflow:

• requestJoin - Request to join an existing team
• approveJoin / rejectJoin - Team lead controls membership

Coordination:

• Direct messaging between agents
• Broadcast messaging to all team members
• Plan approval and rejection protocols

Task system

Teams share a task list at ~/.claude/tasks/{team-name}/:

{
  "id": "1",
  "subject": "Implement OAuth callback handler",
  "status": "in_progress",
  "owner": "auth-backend",
  "blocks": ["2", "3"],
  "description": "Handle OAuth redirect and token exchange..."
}

Workers self-organize around this shared queue:

1. Check TaskList for available work
2. Claim unassigned, unblocked tasks
3. Mark tasks completed when done
4. Create new tasks when identifying additional work

Git worktree isolation

One of the smartest features: each agent works in a separate Git worktree. This prevents file conflicts between concurrent agents. They merge code only when tests pass, keeping the main branch stable even while five agents code simultaneously.

Environment variables

Spawned agents receive context through environment variables:

• CLAUDE_CODE_AGENT_ID - Unique identifier
• CLAUDE_CODE_AGENT_TYPE - Role (frontend, backend, etc.)
• CLAUDE_CODE_TEAM_NAME - Team membership
• CLAUDE_CODE_PLAN_MODE_REQUIRED - Whether plan approval is needed

Why this matters

Context efficiency

Single-agent Claude typically uses 80-90% of its context window before needing a reset. With Claude Code agent teams? Around 40%. Each teammate carries their own context. Investigations happen in their window. Results come back summarized.

This is the real win. Fresh context windows per agent team member prevent the token bloat that cripples single-agent approaches at scale.

Parallelization

A task that takes one agent 2 hours might take an agent team 30 minutes - not because the agents are faster, but because they're working simultaneously on different parts of the problem.

Handling large codebases

Single agents struggle with 50,000+ line codebases. By the time they've loaded enough context to understand the architecture, they've consumed most of their working memory. Agent teams solve this by distributing the cognitive load across specialized swarm members.

The impact on third-party tools

Here's the interesting part: Anthropic has done this before. The community builds creative solutions to pain points, and Anthropic eventually folds the best patterns into core.

Ralph Wiggum loops → Native task management with dependencies and blockers

Manual MCP server management → Tool Search for on-demand loading

Third-party agent orchestration (Claude-Flow, Oh-My-Claude) → Native swarm mode

Tools like Claude-Flow and Oh-My-Claude pioneered multi-agent orchestration for Claude Code. They offered sophisticated features: 32 specialized agents, 5 execution modes, persistent memory with SQLite, distributed swarm intelligence.

Now that swarm mode is native, these tools face an interesting challenge. Native integration means tighter coordination, better performance, and official support. But third-party tools often move faster and offer more experimental features.

The pattern is clear: Anthropic watches what developers need and ships polished native versions. This is healthy for the ecosystem - it validates the demand and raises the baseline for everyone.

Getting started with Claude Code agent teams

With the official release, you can now use swarm mode and Claude Code agent teams without any workarounds:

# Update to the latest Claude Code
npm update -g @anthropic-ai/claude-code

# Start a new session
claude

# Request a team for your task
> Build a REST API with authentication, rate limiting, and comprehensive tests.
> Please use a team of specialists for this.

Claude will create a plan, spawn specialists, and coordinate their work. You'll see real-time updates as agents complete tasks and report back.

When to use swarm mode and agent teams

Good for:

• Large refactors across many files
• Feature development with multiple components
• Projects requiring parallel workstreams
• Codebases that exceed single-agent context limits

Not ideal for:

• Quick fixes and small changes
• Exploratory work with unclear scope
• Security-critical code requiring careful human review
• Simple tasks that don't benefit from parallelization

The bigger picture

We're moving past the era of chatbots and into the era of agent orchestration. Gartner reports a 1,445% surge in multi-agent system inquiries from Q1 2024 to Q2 2025. By the end of 2026, they predict 40% of enterprise applications will include task-specific AI agents.

Claude Code agent teams are Anthropic's answer to this shift. Instead of one powerful model trying to do everything, you get an agent team of focused specialists coordinating toward a goal. It's how human engineering teams work - and now it's how Claude works too.

The implications extend beyond code. If multi-agent orchestration works for software development, it works for other complex knowledge work: research, analysis, content creation, planning. The patterns Claude Code is pioneering today will shape how we interact with AI systems tomorrow.

What's next:

Claude Code agent teams are just the beginning. The swarm infrastructure is in place for even more sophisticated coordination: cross-team collaboration, persistent agent memories, learned specializations. Anthropic tends to iterate quickly once a capability ships.

And we're keeping pace: Cyrus is launching same-day support for Claude Code agent teams and Opus 4.6. If you're using Cyrus with Linear, you'll have access to agent team-powered development workflows from day one.

For now, try it out. Build something that would have been impractical with single-agent Claude. See how it feels to manage Claude Code agent teams instead of prompting an AI assistant.

The future of AI-assisted development isn't one brilliant model. It's agent teams - a swarm.