What a subagent inherits, and what it does not

You spend twenty minutes with Claude working out that the retry logic must not touch the queue module, and why. Then you type: use a subagent to apply that fix the way we discussed.

The subagent has never heard of the discussion. It will not say so. It will produce something confident and plausible, because a task prompt that references a conversation it cannot see is a task prompt with a hole in it, and a hole gets filled.

Lesson 8.1 made the case for delegating. This lesson is about the boundary that makes delegation work, read from the inside: what is in that second window when it opens, and what is not.

A fresh, isolated window

Each subagent starts with a fresh, isolated context window. It doesn't see your conversation history, the skills you've already invoked, or the files Claude has already read. — Subagents

The sentence immediately after it is the one people skip, and it is where the whole lesson lives: "Claude composes a delegation message that summarizes the task, and the subagent works from there."

So the subagent is not reading your request. It is reading a summary of your request that Claude wrote. Everything the subagent knows about your intent survived a round of compression it was not present for.

The one exception is a fork, which inherits the conversation instead of starting fresh. That is Lesson 8.3; everything below describes a non-fork subagent.

What is actually in the window when it opens

The docs enumerate the startup contents exactly (Subagents):

Read the first row twice. A custom subagent does not run Claude Code's system prompt at all:

Subagents receive only this system prompt plus basic environment details like the working directory, not the Claude Code system prompt. — Subagents

The body of the agent file is the whole personality. Authoring that file is Lesson 8.4; what matters here is that a subagent's defaults are its author's defaults, not the ones you have been working under all session.

The five things that never cross

Two of these deserve their exact wording, because both are commonly assumed backwards.

Output style: a subagent runs its own system prompt, so your output style doesn't shape its responses, except in a fork. — Subagents

Auto memory: the main conversation's auto memory isn't loaded. To give a subagent persistent memory of its own, use the memory field. — Subagents

The window is not the size you think

One more thing does not come from the parent, and it is not a piece of content:

Context window size: a subagent's context window is sized by its own model, not the parent's. Delegating to a model with a smaller window gives that subagent the smaller window. — Subagents

That is the whole documented fact, and it is worth resisting the urge to extend it into a rule of thumb about which tasks fit where. What it does tell you is that "route this to a cheaper model" is not only a price decision. A subagent on a smaller model is doing your research inside a smaller budget than the one you were reasoning about when you scoped the task.

What a custom subagent does load

Here is the assumption that costs people the most, because it is the opposite of what "fresh, isolated context window" suggests:

Explore and Plan skip your CLAUDE.md files and the parent session's git status to keep research fast and inexpensive. Every other built-in and custom subagent loads both. — Subagents

Your project conventions are already there. So is the git status snapshot. The context-window walkthrough puts the cost where it belongs:

The subagent loads CLAUDE.md too. Same file, same content, but it counts against the subagent's context, not yours. — Context window

MCP servers and skills come across as well: "The subagent has access to the same MCP servers and skills. It gets most of the parent's tools, minus several that don't apply in a nested context, including plan-mode controls, background-task tools, and by default the Agent tool itself to prevent recursion" (Context window).

Lesson 3.2 showed compaction re-injecting CLAUDE.md and auto memory from disk while everything that had only ever existed in the conversation was summarised away. It is tempting to carry that sorting rule across — on disk survives, in the conversation does not — and here it breaks. Compaction re-injects auto memory from disk, and re-injects the body of every skill you invoked (Context window). The subagent boundary drops both, and both sit on disk either way.

So there is no rule to derive here, only a list.

Explore and Plan are the exception

The two research agents skip both, deliberately, and you cannot change it:

Explore and Plan are the only subagents that omit CLAUDE.md and git status. There is no frontmatter field or per-agent setting to change which agents skip them. — Subagents

Which sounds worse than it is, because of where their output lands:

The main conversation reads Explore and Plan results with full CLAUDE.md context, so most rules don't need to reach the subagent itself. If a rule must, such as "ignore the vendor/ directory," restate it in the prompt you give Claude when delegating. — Subagents

Note the shape of the distinction. A rule that governs how the findings are interpreted is fine where it is. A rule that governs how the search is conducted has to travel. "Ignore vendor/" changes what gets read, so it must be in the brief.

Writing the brief the subagent cannot infer

There is one more mechanic that surprises people, and it applies even when you name the agent yourself:

Your full message still goes to Claude, which writes the subagent's task prompt based on what you asked. The @-mention controls which subagent Claude invokes, not what prompt it receives. — Subagents

You never write the subagent's prompt. You write the message that Claude summarises into one. Which means a fact only reaches the subagent if it is stated plainly enough in your message to survive being summarised.

So the brief carries the three things the boundary strips, and nothing that CLAUDE.md already supplies:

Use a subagent to find every call site that retries a failed publish.

The queue module is off limits — we established that this morning and it is
not written down anywhere.

Report a list of file paths with line numbers and the retry count each site
uses. No code changes, no recommendations.

Three moves: the decision that only exists in chat, restated; the entry point, named, because the subagent cannot see what you already read; and the report shape, specified, because your output style is not doing it for you. Contrast that with "apply that fix the way we discussed", where all three are missing and none of them will announce their absence.

The point

A subagent is not a colleague who was in the room. It is a stranger who has read your project's documentation and nothing else — and who has your CLAUDE.md, your git status, your MCP servers and your skills, in its own copy of the window, paid for out of its own budget.

Write to that stranger. The facts it is missing are exactly the ones you would never think to say out loud, because you and Claude agreed them an hour ago.