Skip to content

Forked vs Fresh Subagents: When to Inherit the Parent Conversation

Fork when the parent's mental model is an asset; start fresh when bias, trifecta exposure, or token budget makes inherited context a liability.

A forked subagent inherits the parent's entire system prompt, tools, and message history; a fresh subagent starts with only the task brief the orchestrator constructs. Claude Code makes the choice explicit through CLAUDE_CODE_FORK_SUBAGENT=1 and /fork, available since v2.1.117 (Claude docs). The same axis exists implicitly in every harness that spawns child agents, but the same orchestrator can correctly fork for one delegation and start fresh for the next — the choice is per-task, not global.

The Decision

Spawn fresh when Spawn a fork when
The subagent needs to question a parent decision (code review, security audit, adversarial test) The subagent needs to extend a parent decision (design variation, continuation, mid-stream draft)
The parent has touched untrusted content (web fetches, MCP server output) and the child has egress The parent's reasoning is load-bearing and a brief would be lossy
The task is one-off — no parallel siblings to amortize cache warmup Two or more siblings will run from the same starting point
The child must reset bias to disagree with the parent The child must preserve the parent's nuance to agree intelligently

Why It Works

A fork's first request shares the parent's prefix exactly — same system prompt, same tool definitions, same message history. The Claude API prompt cache matches on exact prefix, so the fork reads from cached tokens and bills only the appended fork directive. From the Claude Code prompt-caching docs: "A fork ... inherits the parent's system prompt, tools, and conversation history exactly, so its first request reads the parent's cache." Cache reads bill at roughly 10% of the standard input rate (same page).

A fresh named subagent has a different system prompt and tool set, so its prefix does not match the parent's cache. Its first call has no cache hits and it warms its own (5-minute TTL) cache from scratch (Claude docs).

The mechanism explains both directions of the trade-off. Forks are cheap precisely because they carry the parent's entire input distribution — which is also why they inherit the parent's biases, blind spots, and accumulated tool results. Fresh subagents pay a real first-call cost because they reset the distribution — which is also what makes them useful for adversarial work.

When This Backfires

Forking a code review or audit. The fork remembers why every decision was made and confirmation bias rubber-stamps the work. A direct test reported in Mejba Ahmed's field write-up: a forked subagent reviewing authentication code returned cosmetic suggestions; a fresh subagent on the same code flagged a missing constant-time token comparison — a real security bug. Anthropic's own design rationale for making forking opt-in cites the same concern: "Clean slate is sometimes better. For example, a code review agent probably benefits from fresh perspective without anchoring bias from the conversation" (claude-code#16153).

Forking a single small task. Cache warmup is real on the first fork after a heavy parent. A one-off fork on a 180k-token parent pays the cache-write tax without parallel siblings to amortize against. Forks earn their keep when batched.

Forking a trifecta-sensitive child. A fork pulls in every accumulated tool result, including web fetches and MCP output. The Claude docs call this out directly: a fork "drops the input isolation that subagents otherwise provide." If the parent has any lethal-trifecta exposure, the fork inherits the injection surface. The fresh-subagent containment model — only what the orchestrator chose to pass — is the safer default for any child that can act.

Forking past the context cliff. Forks copy the entire parent window. If the parent is already past the degradation threshold, the fork inherits the degraded baseline. Forking does not solve session bloat; it propagates it.

Forking when the task needs to challenge prior decisions. Counterfactual exploration is undermined when the explorer remembers why each option was rejected. Fresh context is the lever that lets a subagent disagree.

Side Effects of Enabling Fork Mode

Setting CLAUDE_CODE_FORK_SUBAGENT=1 changes three behaviors at once (Claude docs):

  • Spawns that would have used the general-purpose subagent become forks. Named subagents (Explore, custom definitions) still spawn fresh.
  • Every subagent spawn runs in the background. Set CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1 to keep spawns synchronous.
  • /fork becomes the fork command instead of an alias for /branch.

A fork cannot spawn further forks (same docs section).

Example

A team is 140k tokens into a design-system session — color tokens, component patterns, and spacing rules are all established in the conversation. Two parallel tasks come up:

  1. Generate two Kanban-card variations that fit the existing system. Fork twice. Both forks see the full design system byte-for-byte and produce variations consistent with it. A fresh subagent would receive Claude's compressed summary ("project uses Tailwind, dark theme, Inter font") and lose the specific spacing scale and shadow treatments that make variations belong together.
  2. Review the authentication module the team just wrote for security issues. Spawn fresh. The fresh subagent has no investment in the implementation choices and can flag the constant-time-comparison gap the author missed.

Both delegations happen in the same session. The fork-vs-fresh choice is per-task, not per-session.

Key Takeaways

  • The fork/fresh axis is a per-task choice, not a global setting — even with fork mode enabled, named subagents still spawn fresh.
  • Forks share the parent prompt cache; their first request bills at cache-read rates because the prefix matches.
  • Fresh is the right default for reviews, audits, and any child that needs to disagree with the parent.
  • Forks earn their keep when the parent's reasoning is load-bearing and at least two siblings will run from the same starting point.
  • A fork drops input isolation — never fork a child that holds egress when the parent has touched untrusted content.
Last reviewed: 2026-05-30
Feedback