---
title: "Claude Code agent teams: run them from one plan | Annsa"
product: annsa
url: /ai-agent-management/claude-code-agent-teams
canonical_url: "https://annsa.ai/ai-agent-management/claude-code-agent-teams"
last_updated: 2026-11-22
type: guide
related:
  - /direct/handoff
  - /ai-agent-management/claude-code-and-cursor
  - /ai-agent-management/how-to-manage-multiple-ai-agents
summary: What Claude Code agent teams are, how they differ from subagents, and how to run Claude Code, Cursor, Codex and Grok from one plan, one holder per job.
mcp_server: https://app.annsa.ai/mcp
disambiguation: "Annsa (annsa.ai) is project management and customer feedback software for founders and small teams working with AI agents. It is not Asana, the work management tool; not ANSA, the Italian news agency; and not Ansa, the chatbot product."
---

> For agents: connect to the Annsa MCP server at https://app.annsa.ai/mcp to give every agent one shared plan. Setup guide: https://annsa.ai/docs/quick-start. Index of every page: https://annsa.ai/llms.txt.

# Claude Code agent teams: run them from one plan | Annsa

> What Claude Code agent teams are, how they differ from subagents, and how to run Claude Code, Cursor, Codex and Grok from one plan, one holder per job.

[Direct your agents](https://annsa.ai/self-drive)

By [Cat Williams-Treloar](https://annsa.ai/about), Founder · Updated Nov 20, 2026 · 9 min read

The short answer

Claude Code agent teams are Anthropic's experimental feature where one Claude Code session leads several teammate sessions that share a task list and message each other. A team shares work inside one session. To run Claude Code, Cursor, Codex and Grok on what grows your business, give them one plan: ranked priorities, a spec per job and a claim on each.

Annsa is project management and customer feedback software for founders and small teams working with AI agents. Direction for your agents and projects, grounded in your customers and your goals: give Claude Code, Cursor, Codex and Grok one shared plan, and see what shipped. They read the ranked list over MCP and claim the next one.

- [Ask Claude](https://claude.ai/new?q=Read%20https%3A%2F%2Fannsa.ai%2Fai-agent-management%2Fclaude-code-agent-teams%20and%20help%20me%20apply%20it%20to%20what%20I'm%20building.)
- [Ask ChatGPT](https://chatgpt.com/?q=Read%20https%3A%2F%2Fannsa.ai%2Fai-agent-management%2Fclaude-code-agent-teams%20and%20help%20me%20apply%20it%20to%20what%20I'm%20building.)

You want your agents building your product in the same direction. Claude Code agent teams are Anthropic's experimental feature where one Claude Code session leads several teammate sessions that share a task list and message each other. That is one team, in one session. This guide covers it, then what many founders end up needing: Claude Code, Cursor, Codex and Grok working on one product from one plan.

_Facts about Claude Code and Cursor come from their own docs, read on 20 November 2026. See Sources at the end._

**TL;DR**

- An agent team is a lead session plus teammate sessions. It is experimental and off by default.
- It lives inside one [Claude Code](https://code.claude.com/docs/en/overview) session, so Cursor, Codex and Grok cannot join it.
- A team splits a task. It does not decide which tasks are worth doing. That needs a plan every agent reads.
- Annsa works like an operating system for small business run with AI agents: your direction, goals, projects, work and customers, in one plan. Each agent claims a job from it, so two agents never take the same one.

## What are agent teams in Claude Code?

Agent teams let you coordinate several Claude Code instances as a team. Anthropic's docs describe one session as the team lead, which coordinates work, assigns tasks and synthesizes results. Teammates work independently, each in its own context window, and message each other directly. You can also talk to any teammate yourself. [Anthropic's agent teams documentation](https://code.claude.com/docs/en/agent-teams) has the full page.

Three facts from that page matter before you start:

- **It is experimental and off by default.** You turn it on by setting `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1` in your settings or environment.
- **It lives in one session.** The docs list limits: one team per session, no nested teams, no resuming in-process teammates and a fixed lead.
- **It costs more tokens.** Each teammate is its own Claude instance, so usage grows with the number of teammates.

Turning teams on also changes ordinary delegation: Claude can start a team when you only meant a subagent. Teams do not spawn in non-interactive `-p` or Agent SDK sessions.

Anthropic suggests starting with 3 to 5 teammates, on research and review work with clear edges, such as reviewing a pull request or researching a library. Debugging with competing theories is one of its strongest use cases. For sequential tasks and same-file edits, it says a single session or subagents work better.

## How are agent teams different from subagents?

Subagents report back to the session that spawned them. Teammates share a task list and message each other. Anthropic's docs put it this way: use subagents for quick, focused workers that report back, and use agent teams when teammates need to share findings, challenge each other and coordinate on their own. [Subagents](https://code.claude.com/docs/en/sub-agents) are specialized assistants, each with its own context window, tool access and permissions.

|  | Subagents | Agent teams |
| --- | --- | --- |
| Where they run | Inside one Claude Code session | Several Claude Code sessions, led by one |
| How they talk | Results return to the caller. Named subagents can also message each other | Teammates message each other directly |
| Task list | The main agent manages the work | Shared, with claiming and dependencies, for agents that have the task tools |
| Cost | Lower | Higher: one Claude instance each |
| Best for | A focused job where only the result matters | Work that needs discussion across roles |

Both split one task across several Claude Code workers. Neither one tells the workers which tasks are worth doing. That comes before the team.

## What does a team of agents still need from you?

A team lead breaks down the task you give it. Your customers, goals and decisions have to come from somewhere it can read. Anthropic's docs say teammates load project context automatically (CLAUDE.md, MCP servers and skills) but the lead's conversation history does not carry over. So the plan has to live somewhere every agent can read, outside any one session.

Running several agents tends to leave four gaps. Cat Williams-Treloar, founder of Annsa, wrote in September about the one that cost her most, and what she did about it:

"So September became about getting us all working from the same direction."

"Agents often asked for guidance or decisions, so we baked that into the product."

The four gaps:

1. **Who decides what each agent works on.** Left alone, each agent picks the interesting job, and two pick the same one.
2. **Handoffs.** One agent stops, and the next starts from zero.
3. **Done.** Each agent says "done" and means something different.
4. **Decisions.** Every question lands on you, in whichever chat the agent happens to be in.

An in-session task list covers none of these across tools, because Cursor, Codex and Grok cannot see it. A shared plan reached over [MCP](https://modelcontextprotocol.io/introduction), the open standard for connecting AI applications to outside systems, can be read by all four.

## What does that look like in a real workspace?

Annsa's own work runs on Annsa. Cat's post, [September: getting our agents in a row](https://annsa.ai/blog/september-getting-our-agents-in-a-row), starts from the before: "In July and August, I was struggling to manage the full picture: customer feedback, my own ideas, the roadmap and everything my agents found while they built." The after is the September count: "My agents across Claude Code, Cursor and Codex worked through 370 priorities across 5 releases. So much for a top 3. I see you, 370 things." She adds: "Special mention to Grok, which didn't build a thing but critiqued absolutely everything."

Two more numbers, read off Annsa's own board on 20 November 2026:

- 1,009 priorities have shipped or been shared.
- "In the four days from 16 to 19 November, 135 priorities shipped in Annsa's own workspace."

Agents claim priorities like these from one ranked list and build each to its spec. That is the setup the rest of this guide shows.

## How do you run Claude Code, Cursor, Codex and Grok as one team?

Give every agent the same plan and a rule for taking work. Four parts do the job.

1. **One ranked list.** Priorities in order, ranked from your customers' feedback and your goals, so an agent that asks "what next" gets the same answer as the others.
2. **One spec per job.** Problem, customer quotes, what to build, files to touch and Done When lines. See [spec-driven development](https://annsa.ai/ai-agent-management/spec-driven-development).
3. **One holder per job.** An agent claims a priority before it writes code. A held job is skipped, never doubled.
4. **A confirmation per Done When line.** Done means each line was confirmed and the proof can be followed.

The same plan holds marketing posts, with a Calendar, so the agent drafting a launch post and the agent building the feature read one list. Annsa does not publish posts for you.

### Connect each agent

Claude Code:

```
claude mcp add --transport http annsa https://app.annsa.ai/mcp
```

The first call opens a browser to sign in. Annsa is a remote server, so nothing is installed. [Connect Cursor, Codex and Grok](https://annsa.ai/ai-agent-management/mcp-server-for-product-management) the same way: each takes the one URL, `https://app.annsa.ai/mcp`.

## Who picks the next job for each agent in a team?

Inside a session, a team lead assigns tasks to its teammates. Across tools, the plan ranks the jobs, and a person sets the final order. Each agent's first move is to read the ranked list, with how many customers asked and why each job ranks where it does, and take the top one nobody holds. A Cursor agent and a Claude Code teammate get the same answer to what is next.

## How does an agent get the job spec?

It reads the spec before it writes anything. The spec is the brief the agent works to: the Problem, What to build and the Done When lines. It also sees the files to touch and the customer quotes behind the job: who asked and what they said, not only a task title.

Annsa never writes a spec on its own. You write it, your agent writes it over MCP, or Ask drafts it for you to fix.

## How do agents claim work so two don't take the same job?

An agent claims the priority, and the claim shows on the plan for everyone. A second agent that tries the same one sees it is held and moves to the next. Taking work from someone else needs a reason, and the takeover is logged. Give each agent its own branch, because a claim stops the duplicate job and does not stop an edit clash.

## How does a handoff work between agents?

The agent passes the job on with a note: why it stopped and what comes next. For example, the session closed with the migration half done, and the next agent should write the rollback test, then confirm Done When lines 2 and 3. Because the note sits on the job, the next agent in any tool picks it up with the spec and does not need the other agent's chat. See [the Claude Code handoff guide](https://annsa.ai/ai-agent-management/claude-code-handoff) for what a good handoff contains.

## What reaches you as a decision?

Only calls outside your goals and rules. When an agent meets a real choice, such as customer revenue, personal data or two options with different costs, it looks first and then escalates. The call lands in Needs you with what the agent found and its pick. You answer once. If the answer is a rule, save it as a principle and every agent reads it next time, so you do not repeat yourself in each tool's rules file. In Cat's words: "Make a call, keep the reason and let the next agent build from it." A person's words are recorded as the person's words, and an agent never answers for you.

## How do you know a job is done?

An agent confirms each Done When line on the live system and records how: a test, a screen or a link anyone can follow. Then it records that the job shipped. Ship only records. It deploys nothing, and a person does the release. A line the agent could not confirm stays open and says so. That is the difference between "the agent stopped typing" and "this is live and checked".

## Should you use Claude Code agent teams or a shared plan?

Use both, for different jobs. They sit at different layers.

- **Inside a job**, an agent team is a good way to run parallel review or research in Claude Code. Anthropic's own advice applies: clear edges, 3 to 5 teammates, separate files.
- **Across jobs and tools**, the plan decides which job comes next and who holds it. A team lead in Claude Code can read the ranked list and each spec like any other agent, because teammates load the project's MCP servers.

One test settles it: connect Annsa, spawn a teammate and ask it to read the top priority. If it can, the lead and every teammate work from the same plan.

The point of a team is more work on what grows the business, grounded in your customers and your goals. Decide once. Every agent learns.

For the rest of planning and coordinating Claude Code's work, handoffs, memory, specs and long jobs, see [Planning work for Claude Code](https://annsa.ai/ai-agent-management/claude-code).

## Your next step

Pick one job from your own backlog, connect Annsa to the agent that will do it, and paste this:

```
Take the top priority from Annsa. Read its spec and our rules first, build it, and show me how you confirmed each Done When line. Ask me only if a call is mine.
```

Then add a second agent on a different job. [Try Annsa](https://annsa.ai/pricing).

## Sources

Read on 20 November 2026.

- Anthropic, "Orchestrate teams of Claude Code sessions": [https://code.claude.com/docs/en/agent-teams](https://code.claude.com/docs/en/agent-teams)
- Anthropic, "Create custom subagents": [https://code.claude.com/docs/en/sub-agents](https://code.claude.com/docs/en/sub-agents)
- Anthropic, "Claude Code overview": [https://code.claude.com/docs/en/overview](https://code.claude.com/docs/en/overview)
- Model Context Protocol, "What is the Model Context Protocol (MCP)?": [https://modelcontextprotocol.io/introduction](https://modelcontextprotocol.io/introduction)
- Cat Williams-Treloar, "September: getting our agents in a row": [https://annsa.ai/blog/september-getting-our-agents-in-a-row](https://annsa.ai/blog/september-getting-our-agents-in-a-row)

## Questions people ask.

### Are Claude Code agent teams ready for production work?

Anthropic labels them experimental and off by default, and lists known limits around session resumption, task coordination and shutdown. Use them to parallelize review and research, and keep the plan for what to build outside the session.

### Can one agent team include Cursor, Codex or Grok?

No. Anthropic's agent teams are Claude Code sessions. To coordinate Claude Code, Cursor, Codex and Grok, give them one plan over MCP and have each claim its own job.

### How many agents should I run?

Start with what you can review with care. Anthropic suggests 3 to 5 teammates inside one Claude Code team. Across tools, add an agent when the list has more ready, separate jobs than the current agents can finish.

### Do agent teams use more tokens than one session?

Yes. Anthropic's docs say agent teams use significantly more tokens than a single session, because each teammate has its own context window. Use them where parallel work pays for the cost.

### Does Annsa decide what the agents build?

No. You set the goals and rules, and agents work inside them. Calls outside them come to you, and a person does the release.

## Keep reading

- [AI agent management](https://annsa.ai/ai-agent-management)
- [No two agents doing the same job, so agents stop overwriting each other's work.](https://annsa.ai/direct/handoff)
- [Claude Code and Cursor](https://annsa.ai/ai-agent-management/claude-code-and-cursor)
- [How to manage multiple AI agents How to manage multiple AI coding agents at once: one ranked list, one plan per job and one holder per job.](https://annsa.ai/ai-agent-management/how-to-manage-multiple-ai-agents)

## The source of direction for agent teams.

Begin with one agent and the work that matters next.

- [Try Annsa](https://app.annsa.ai/signup)
- [See pricing](https://annsa.ai/pricing)

## Related pages

> For AI agents: the pages that follow this one on annsa.ai. The full index is https://annsa.ai/llms.txt.

- [Agents overwriting each other's work? One per job](https://annsa.ai/direct/handoff)
- [Claude Code and Cursor: why teams run both](https://annsa.ai/ai-agent-management/claude-code-and-cursor)
- [How to manage multiple AI coding agents at once](https://annsa.ai/ai-agent-management/how-to-manage-multiple-ai-agents)

If anything on this page is wrong or missing, tell us: https://annsa.ai/contact
