Claude Code Agents: Subagents, Teams and Agent View

"Claude Code agents" is not one feature. The docs describe five ways to run several Claude sessions at once: subagents, agent view, agent teams, dynamic workflows and projects. Subagents are the everyday tool and are on by default. Agent teams are experimental and off by default. We checked all of this against Anthropic's docs on 31 October 2026.

Quick facts

For the single-feature guide to writing subagent files, see Subagents. This page is the map of all the agent surfaces and how to choose between them.

The five ways to run agents

Anthropic's "Run agents in parallel" page compares them in one table. We have kept its logic and put it in plain words.

One line from the docs is worth keeping in mind: in every approach the workers are Claude sessions. If you want a different tool involved, expose it to Claude as an MCP server. Our Claude Code MCP servers page covers that route.

Three helpers sit beside these without being agent types themselves. Worktrees give each session its own git checkout. Cross-session messaging lets Claude list and message your other sessions. The /batch skill splits one large change into 5 to 30 worktree-isolated subagents.

Subagents

A subagent is a worker with its own context window, system prompt, tool list and permissions. Claude hands it a task, it works on its own, and a summary comes back. The point is to keep noisy work out of your main conversation. A test run that prints 400 lines of logs is a good fit: you want the answer, not the logs.

The built-in ones

Claude Code ships a few and uses them without being asked.

Explore and Plan start without your CLAUDE.md files and the git status snapshot, to stay fast and cheap. Explore also takes a thoroughness level that Claude sets: quick, medium or very thorough. A project or user subagent named Explore overrides the built-in one, which is how you would pin exploration to a cheaper model.

Your own

A custom subagent is one Markdown file. Only name and description are required. The description tells Claude when to hand work to it, so write it as a trigger, not a title.

---
name: log-reader
description: Reads long build or test logs and reports only the failures. Use after any test or build run.
tools: Read, Grep, Bash
model: haiku
maxTurns: 12
---
You read logs. Report each failing test or error with the file, the line and
the first useful message. Do not suggest fixes. Keep the answer under 200 words.

Frontmatter fields the docs list beyond those: disallowedTools, permissionMode, skills, mcpServers, hooks, memory, background, omitClaudeMd, effort, isolation, color, initialPrompt and experimental. Field names are camelCase and must match exactly. A misspelled field is ignored without an error. The docs suggest running claude --debug and searching the log for "does not recognize or apply" when a subagent behaves oddly.

A few fields do real work:

• `tools` and `disallowedTools` limit what the agent can touch. A reviewer with Read, Grep, Glob cannot edit.
• `mcpServers` scopes a server to one subagent, either by naming one you configured or by defining it inline. That keeps a heavy server's tool list out of the main conversation.
• `isolation: worktree` runs the subagent in a temporary git worktree, so its edits do not collide with yours.
• `memory` takes user, project or local and lets the agent learn across sessions.
• `maxTurns` stops a runaway. The output comes back marked as partial, and Claude can resume the agent.

Limits that matter

• Concurrency. At 20 running subagents, another spawn fails with "Concurrent subagent limit reached". Change it with CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS.
• Nesting. A subagent can spawn its own, up to three layers below the main conversation. Set CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH to change that, and 1 turns nesting off. Leave Agent out of a subagent's tool list to keep it from spawning.
• No shared history. A subagent does not see your conversation. Claude writes a delegation message, and the subagent works from that. A fork, started with /subtask, is the exception: it inherits the conversation.
• Turning them off. Deny the Agent tool in permissions.deny to stop all delegation. CLAUDE_CODE_DISABLE_EXPLORE_PLAN_AGENTS=1 removes only Explore and Plan.

Agent view

Agent view is a different idea. It is one screen for background sessions you started yourself, not workers Claude spawns. Open it from the shell:

claude agents

Each row is a full Claude Code conversation that keeps running without a terminal attached. The screen groups them as needs input, working and completed. You dispatch a new session from the input at the bottom, peek at a row, reply, or attach to enter the whole conversation.

Ways in, from the docs:

• claude --bg "<prompt>" from a directory starts a background session.
• /bg inside a session moves it to the background.
• The left arrow on an empty prompt backgrounds the session and opens agent view in one step.

A session you dispatch from agent view moves into its own git worktree before it edits files, so three tasks do not fight over one checkout. Sessions report to you, not to each other. If you want them to pass notes, the docs point to cross-session messaging.

It is labelled a research preview, and the docs say the interface and shortcuts may change. We would not build a team process around its key bindings yet.

A confusing detail: the /agents command inside a session does not open agent view. It prints a notice pointing to the subagent file locations. The thing that opens agent view is claude agents from the shell.

Agent teams

A team is one lead session plus teammates. Teammates have their own context windows, share a task list, claim work and message each other directly. You can also talk to any teammate yourself.

Turn it on in settings.json:

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

Without that variable no team is created and Claude does not propose teammates. Spawning teammates also needs an interactive session, so claude -p and Agent SDK runs do not create them.

There are two display modes. In-process mode works in any terminal. Split-pane mode gives each teammate a pane and needs tmux, or iTerm2 with the it2 CLI. It is not supported in VS Code's integrated terminal, Windows Terminal or Ghostty.

What teams are for

Anthropic names four good fits: research and review with several angles at once, new modules where each teammate owns a piece, debugging with competing hypotheses, and changes that span frontend, backend and tests. It also says plainly that teams add coordination overhead and use significantly more tokens, and that sequential work or same-file edits are better done in one session or with subagents.

Known limitations

The docs list these themselves:

• /resume and /rewind do not restore in-process teammates.
• Task status can lag, because teammates sometimes fail to mark tasks complete.
• Shutdown can be slow.
• One team per session, and no nested teams.
• The lead is fixed for the session's life.
• Teammates start with the lead's permission mode. You can change one afterwards, but not set it at spawn time.
• Teams do not isolate teammates in worktrees. You have to partition files so each teammate owns a different set.

You can reuse a subagent definition as a teammate by naming the subagent type when you ask Claude to spawn it.

Dynamic workflows and projects

Workflows are for jobs that outgrow a handful of subagents. A script holds the plan, runs many subagents and cross-checks their results, instead of Claude judging turn by turn. /workflows lists running and finished runs. Our Claude Code workflows page looks at the pattern.

Projects are the cloud-side option: one ongoing conversation at claude.ai/code or in the desktop app, where Claude starts parallel threads. The docs mark it public beta on Pro, Max and Ultra, rolling out gradually, and not yet offered on Team or Enterprise. It sits outside what a terminal user needs day to day, so we say no more on it here..

Choosing between them

Three questions from the docs settle most cases.

1. Who coordinates? Claude inside one conversation means subagents. You, handing off tasks, means agent view. Claude supervising a group means teams. A script means workflows.
2. Do the workers need to talk? Subagents report only to the caller. Agent view sessions report only to you. Teammates message each other.
3. Do the tasks touch the same files? Use worktrees. Subagents and your own sessions can each use one. Teams do not, so split the files by hand.

Checking on running work

The command depends on what you started.

Cost and safety

Several agents at once means several model sessions billed at once. Anthropic's costs page covers rate limits, and the parallel-agents page carries a plain warning about multiplied token use. Two cheap habits help: give read-only helpers a cheaper model, and set maxTurns on anything that could loop.

On safety, subagents inherit the parent's permission rules, and most built-in ones are restricted. A custom subagent with permissionMode: bypassPermissions skips prompts, so reserve it for isolated worktrees and trusted tasks. A subagent's returned summary is text that enters your main context, so a page or file it read could try to steer you. Scope its tools tightly, as you would for any agent that reads untrusted input. If an agent reaches a database or cloud account through MCP, pair it with a read-only role. Our MCP clients page shows how the agents differ on approvals.

Alternatives in other agents

The same patterns exist elsewhere under other names. Codex has its own subagents, and Gemini CLI has them too; our Subagents page compares their file formats. For a full Claude Code overview, see Claude Code. The daily commands live in the cheat sheet.

Our take

We did not run these features for this page. This comes from Anthropic's documentation as it stood on 31 October 2026.

The naming is the hard part, not the features. "Agents" shows up in claude agents, in /agents, in agent teams and in the subagent folder, and they are four different things. Once the names are sorted, the picture is simple. Subagents are the default tool and the safest. Agent view is for handing off a pile of independent tasks. Teams are for the rare job where workers must talk, and they are still experimental.

Our advice for a normal developer is to start with Explore and one custom read-only reviewer, then try agent view when you notice yourself opening a third terminal tab. Leave teams until you have a task that really splits into owned file sets. Whatever you pick, expect the bill to track the number of agents.

A short checklist

1. Run a task and watch whether Claude delegates to Explore on its own.
2. Write one subagent with a narrow tools list and a trigger-style description.
3. Set maxTurns and, for write-capable agents, isolation: worktree.
4. Try claude agents with two independent tasks.
5. Enable agent teams only in a throwaway repo first.
6. Watch token use for a day before scaling up.

Frequently asked questions

What are Claude Code agents?

Claude Code has five documented ways to run work in parallel: subagents, agent view, agent teams, dynamic workflows and projects. In every one, the workers are Claude sessions.

What is the difference between subagents and agent teams?

A subagent works inside one session and returns a summary to the caller. In an agent team, separate sessions share a task list and message each other directly. Teams are experimental and off by default.

How do I open agent view?

Run claude agents from your shell. Inside a session, /bg moves that session into the background, and pressing the left arrow on an empty prompt does the same and opens agent view.

How many subagents can run at once?

By default 20 in one session. You can change the limit with CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS.

Do agents cost extra?

Each one is its own model session, so tokens add up. Anthropic's docs warn that several sessions or subagents at once multiply usage.