There is a point in most long sessions where you want a second pair of hands. The agent is working through something, and a separate question appears that deserves real investigation - not a quick lookup, but reading files, running commands, checking whether something is actually true. Handing that to a fresh subagent sounds right, until you start writing the prompt and realize you would have to re-explain the entire situation first. The task is thirty seconds of work; describing the context around it takes ten minutes.

Claude Code provides several ways to handle this. The vocabulary can be confusing because forking a conversation and forking a subagent are related but different ideas. The useful distinction is what context the new session receives and whether you continue the work yourself or delegate it.

Behavior below reflects the Claude Code documentation as of September 2026. This area has changed across releases, so check the commands reference if you are reading this much later.

Fresh Context or Inherited Context

Every option comes down to one question: should the second agent start from nothing, or from what you have already done?

A fresh subagent gets its own context window. It receives the task delegated to it and its configured tools and permissions, but it does not inherit the main conversation history. That isolation is the point - it can read files, search the codebase or investigate a problem without filling the main conversation with all of its intermediate work. When it finishes, a summary of its work can be returned to the main conversation.

The cost is that it does not know the conversation that led you there. If the task depends heavily on decisions, discoveries or dead ends from the current session, you may need to provide that background yourself.

A forked subagent is different. It inherits the parent's conversation context rather than starting with a fresh conversation. That gives it access to the requirements, decisions, discoveries and other information already present in the conversation, allowing it to begin work without reconstructing the entire briefing.

What Forking Does Not Isolate

Worth being precise here, because "isolated" can mean different things.

A forked subagent has its own conversation context. Its investigation does not simply become a sequence of additional messages in the parent's conversation. The fork can perform its own investigation while the main session remains focused on its original task.

That is not the same as filesystem isolation. Forking conversation history does not automatically create a separate copy of the working tree. If the forked agent works in the same project directory, its file operations can affect that working tree and therefore be visible to other sessions using it. If separate working copies are required, Git worktrees provide that isolation.

So the important distinction is: Conversation isolation is not filesystem isolation.

Branching the Conversation

Claude Code also lets you branch a conversation when you want to explore a different direction yourself.

/branch creates a branch of the current conversation and switches you into it, while preserving the original conversation. You can therefore take the existing context in a different direction without losing the original session.

This is different from delegating work to a subagent. With a subagent, another agent does the work. With a conversation branch, you continue the work.

Forking a Conversation and Forking a Subagent

The terminology becomes easier if you separate the two ideas.

Forking a conversation means creating another session from the conversation you already have. The new session inherits the conversation history, while the original remains available.

Forking a subagent means starting delegated work with that existing conversation context available to the new agent. The purpose is to give the subagent the background it would otherwise have needed you to explain.

In both cases, the important resource being inherited is conversation context.

Conclusion

None of this is worth memorizing as a command list.

A fresh subagent is not worse than a fork. Isolation is genuinely valuable for read-heavy work like research or review, where you want a large investigation to happen elsewhere and only the useful result to return to your context.

A forked subagent is useful when the investigation needs to understand the conversation that led you there. It saves you from reconstructing the briefing.

And a conversation branch is useful when you want to continue from the same history in a different direction.

The real question is not "Which command do I use?" It is "What should this agent inherit, and who should continue the work?"

Relevant Training

Similar Claude Code topics, such as permission modes, project context and memory are covered in detail in Agentic Application Development with Claude Code, part of the Claude AI learning program. This course is backed by hands-on Cloud Labs, where you get your own temporary Google Cloud project to work in.