What you will learn
- The six documented built-in agent types and what each one does
- What Explore, Plan, and general-purpose each do, and how their costs differ
- The two narrow helper agents and the catch-all claude agent
- Why agent type is only one part of the cost
Explore and Plan are easy names to recognize in the terminal. The other built-in types are worth knowing too.
There are six documented built-in types today. Which ones run depends on your task and configuration.
The labels tell you what role an agent has. They do not tell you its complete cost: model selection, context, caching, and the length of the job still matter.
This is the full catalog. It matters for a concrete reason, not as trivia: agent types differ in their roles and available tools, while model settings and token use determine cost, so the moment you can name the type Claude just spawned, you can assess whether it was the right tool for the job. Think of it the way you would think about hiring. You would not staff a job without knowing whether the person on it is a junior researcher, a senior engineer, or someone wired up to do one specific small task. The agent type is exactly that distinction. An unnamed agent is an unaccountable one. Knowing the names helps.
The six agent types
Claude Code documents six built-in agent types. The subagents documentation is the source of record, and it describes automatic delegation, inherited permission rules, and tool restrictions for most built-in types.
The six are Explore, Plan, general-purpose, claude, statusline-setup, and claude-code-guide. Explore and Plan focus on research. General-purpose handles work that can include edits. The claude type is a catch-all and the default for dispatched background sessions. The two helpers handle status-line setup and Claude Code questions. A subagent has its own working context and returns a result, but a fork begins with the available parent history. You can also define custom types.
The useful distinction is what an agent can touch. Explore and Plan have read-focused tool restrictions. General-purpose can use the tools available to it, including edits when permissions allow. The helpers have narrow jobs. Model defaults are documented, but an agent label alone does not tell you how many tokens it will use or what those tokens cost.
It also helps to be clear about what these presets are not. They are not separate AI products, and they are not models you pick from a menu. They are configurations of the same underlying system, each tuned for a job. The phrase “Claude automatically uses when appropriate” in the documentation carries the whole design: Claude can choose an agent type automatically, when it decides a piece of work belongs in a separate context. You can also request a specific agent. The agent call and task views make that choice inspectable. Knowing the six names helps you judge it.
The diagram shows five examples from the six-type catalog. The claude catch-all is described above.
Explore, the read-only one
Explore handles read-focused codebase research. Claude delegates to it when, in the documentation’s words, “it needs to search or understand a codebase without making changes.” It reads. It does not write. That restriction is the point: a read-only researcher has fewer ways to change your files, and what it finds stays out of your main conversation.
The tool restrictions reduce modification risk, though they do not make every answer correct or every data access harmless. The separate context is useful too. When Explore reads forty files to answer one question, those forty files do not land in your main context window. Its answer does, and the size of that answer still matters. This can keep the main conversation smaller. The cost depends on retained context, caching, model rates, and whether usage is billed through a subscription or API.
Since publishing, one difference between the five has turned out to matter more than either the model or the tool list. Explore and Plan are the only two agent types that skip your CLAUDE.md, and Anthropic’s subagent documentation states there is no frontmatter field or per-agent setting that changes it. So the read-only pair is also the rules-free pair. That is a defensible trade for research speed, and it means the catalog above has a column it does not show: whether an agent type can see your project instructions at all. Checked again on July 30, 2026, and the behaviour holds. I wrote up how to verify it on your own setup in which agents read your CLAUDE.md.
(November 17, 2026 update: that July check concerned CLAUDE.md loading. Current startup documentation says Explore and Plan skip initial CLAUDE.md files and the git-status snapshot, but path-specific instructions can still load when they read files. Custom agents can now use omitClaudeMd to skip those initial instruction files.)
Two details make Explore worth knowing by name. First, it has a thoroughness dial. When Claude invokes Explore it picks a level: quick for a targeted lookup, medium for balanced exploration, very thorough for a wide sweep. A more thorough search may read more files and use more tokens. The level can affect cost, but it does not set a fixed file count or token budget. Picture a session where you ask a small, pointed question, “where is this one constant defined,” and Claude reaches for a very thorough sweep. That is overspending on a job that needed a quick lookup. Picture the reverse: you ask Claude to understand how a whole feature hangs together and it does a quick pass, then proposes a change built on a half-read picture. That is underspending, and it costs you later in rework. Knowing the dial exists lets you read those moments. If a result feels thin, you can ask Claude to look harder. If a simple question burned a lot of tokens, you know which dial got turned too far.
Second, Explore skips the initial CLAUDE.md and git-status injection. Give it the project requirements needed for the research, and remember that path-specific instructions may still load when it reads files. Treat its answer as research to check against your requirements.
Plan, the plan-mode one
Plan is Explore’s close relative, scoped to one situation. When you are in plan mode and Claude needs to understand your codebase before proposing a plan, it delegates that research to the Plan agent. Like Explore, Plan skips the initial CLAUDE.md and git-status injection. That does not guarantee a lower model rate or prevent later instruction loading.
If Plan and Explore both do read-only research, a fair question is why there are two of them at all. Why not point plan mode at Explore and be done? The answer is about where the reading lands. The subagents documentation gives Plan its own reason for being: in plan mode, Claude delegates research to the Plan subagent so that the exploration output stays in a separate context window while the main conversation remains in plan mode. Read that carefully. The point is isolation. Plan mode is supposed to be a phase where Claude looks but does not change anything, and the research that feeds a plan can run to many files. You do not want all of that reading piling into the conversation you are about to approve a plan from.
That separation keeps the research context apart. Plan mode is intended to separate planning from implementation, subject to its documented permissions, and the cleanest way to keep that promise is to do the heavy reading somewhere else and hand back only a summary. The Plan type is that somewhere else. It is the sanctioned hop: plan mode needs to understand your code, so it hands the research to Plan, gets a summary back, and uses that summary to build the plan, while reducing file dumps in the main conversation. You will rarely think about Plan directly, because it only appears inside plan mode and the label you see on screen is the planning work, not the agent type. But it is the reason plan mode can explore your codebase at all and still feel like a clean, look-but-do-not-touch step.
(Update, June 2026: an earlier version of the docs justified Plan as a way to “prevent infinite nesting” because subagents could not spawn other subagents. That rule changed. As of Claude Code v2.1.172 a subagent can spawn its own subagents, and the docs dropped the no-nesting language, which is why the postscript below talks about runs that fan out into hundreds of agents. Update, August 1, 2026: the default ceiling is now three levels, set by v2.1.219 after v2.1.217 had briefly turned nesting off entirely. Plan’s job is still the same in practice: keep plan-mode research in its own context window so the conversation you approve from stays read-only.)
November 17, 2026 clarification: version 2.1.217 disabled nesting by default. The later three-level default and plan-mode permissions are separate settings. Plan keeps research in a separate context; it does not itself enforce the permissions of the main session.
General-purpose, the multi-step worker
General-purpose is the type that does the heavy work, and it is the one most worth understanding in depth. It is the agent Claude routes to for complex, multi-step tasks that need both exploration and action. Where Explore only reads and Plan only researches, general-purpose has the tools available to subagents and can change files when permissions allow.
That full tool set is the line that separates it from the research pair, and the separation cuts both ways. It is what makes general-purpose able to finish a real task end to end, the kind that needs to read some code, decide on a change, and then make the change. Explore could do the reading and stop. General-purpose reads, then acts. But the same write access that makes it useful is what makes it the one to be careful with. A read-only agent can still produce a misleading answer or access sensitive information. A general-purpose agent has a worst case of an unhelpful change, and an unhelpful change is something you then have to find and undo. The capability and the risk are the same property looked at from two sides.
General-purpose normally uses the main conversation model, though settings can override it. Explore and Plan can use that model too. Forks inherit the available parent history, and local interactive forks are now enabled by default on supported surfaces. Fresh non-forks still receive their startup instructions and task briefing. How the general-purpose agent works covers the routing, context, and cost details.
For this catalog, the thing to hold onto is its place in the set. General-purpose is the generalist among the built-in types. Claude can route multi-step research and modification here; the claude type also provides a catch-all for tasks outside the specialized types. The practical read on that is a question of scope. If what you need is a search, the right answer is a read-only agent, and a general-purpose agent on a search job may have broader tools than it needs. If what you need is a multi-step change with reading and editing braided together, general-purpose is the correct tool and a read-only agent could not make the required edits. The skill is not avoiding general-purpose. The skill is noticing when a task that got routed to it was really a read in disguise, and noticing when a job is really big enough that the worker rate is money well spent. And above that ceiling sits one more question, when no single worker is enough and the job wants a script coordinating many of them.
The two helper agents
The last two types are narrow helpers. Their task scope is useful to know even though their total cost is not fixed in advance.
statusline-setup defaults to Sonnet, and Claude uses it when you run /statusline to configure your status line. claude-code-guide defaults to Haiku for questions about Claude Code features, settings, or commands. I read those choices as matching the model to a narrow job. The documented defaults do not establish Anthropic’s reasoning or guarantee a low total cost.
I would check actual model selection and token use when cost matters.
You do not normally need to invoke the helpers directly, though /statusline is a user-triggered task. Explore reads, Plan researches for planning, general-purpose can explore and act, and claude handles tasks without a more specialized type and dispatched background sessions. The two helpers handle narrower tasks. Use those roles to inspect the routing, then check the model, context and usage before judging the cost.
A June 2026 postscript: this catalog now gets exercised at a different scale. With dynamic workflows and the ultracode setting, Claude can spawn dozens to hundreds of subagents in one run, and every one of them arrives the way the five above do: in a fresh context window, knowing nothing you did not put in its briefing. Reading the terminal one agent at a time was practice. The fan-out era grades you on it.
(November 17, 2026 update: a fresh agent still receives its system instructions and configured startup context as well as its task briefing. A fork inherits the available parent history. That is separate from the agent type.)



