Guides

Claude Code context window explained: what fills it, and what /compact keeps

Published October 30, 2026 · Last checked October 30, 2026

The context window holds everything Claude knows about your session: your instructions, the files it reads, its own responses, and content that never appears in your terminal. This page walks through Anthropic's Explore the context window documentation: what loads at startup, how to check usage, what happens when the window fills, what is still there after /compact, and how /compact, /clear and /rewind each work. The documentation was checked on October 30, 2026.

What goes into the context window

The documentation uses an interactive timeline that plays a session from startup to compaction. Its token counts are representative, not your real usage. As the documentation describes it, the order is roughly this:

• Before you type anything: CLAUDE.md, auto memory, MCP tool names, and skill descriptions all load into context. AGENTS.md files can load in place of CLAUDE.md. Your own setup may add more here, like an output style or text from --append-system-prompt.
• As Claude works: each file read adds to context, path-scoped rules load automatically alongside matching files, and a PostToolUse hook fires after each edit.
• The follow-up prompt: a subagent handles the research in its own separate context window, so the large file reads stay out of yours. Only the summary and a small metadata trailer come back.
• At the end of the timeline: you run /compact, which replaces the conversation with a structured summary. Most startup content reloads automatically; the table below shows what happens to each mechanism.

For writing subagents, see Claude Code subagents. For skills, see Claude Code skills. For CLAUDE.md, see how to write CLAUDE.md.

How to check context usage

The documentation says to run /context at any point to see your actual usage: a live breakdown by category with optimization suggestions, including which CLAUDE.md and auto memory files loaded. Run /memory to open and edit those files.

The commands reference describes the two commands like this:

The costs documentation adds that /usage checks your current token usage, and that you can configure your status line to display it continuously. /usage shows session cost, plan usage limits, and activity stats.

What happens when the context fills up

Claude Code compacts automatically as you approach the limit, so a full context window does not end your session. The automatic pass works the same way as the /compact step in the timeline.

The point where automatic compaction runs depends on your model and configuration. The documentation keeps the per-model default thresholds, and the fix for when Claude Code assumes the wrong window for your model ID, on the model-config page. This page gives no specific numbers.

If you need a larger window rather than a smaller conversation: the documentation says Fable models, Sonnet 5 and later, Haiku 5.5, Opus 4.6 and later, and Sonnet 4.6 support a 1 million token context window. Availability by plan and how to select a [1m] model variant are in its Extended context section. It also says compaction works the same way at the larger limit.

What survives compaction and what does not

When a long session compacts, Claude Code summarizes the conversation history to fit the context window. As of v2.1.198, the summarization request inherits your session's extended thinking configuration, so it reasons with thinking enabled when your session has it enabled and stays off otherwise. Thinking affects only how the summary is produced; your session settings are unchanged afterward. What happens to each kind of content depends on how it was loaded:

Three details the documentation calls out:

• File re-reads have a size limit. Right after compaction, Claude Code re-reads up to five of the files Claude has read or edited in the session, choosing the ones modified most recently. A file over 5,000 tokens comes back as a path reference without its content, shown as Referenced file instead of Read.
• Path-scoped rules and nested CLAUDE.md files get summarized away. They load into message history when Claude reads, writes, or edits their trigger file, so compaction summarizes them away with everything else. If a rule must persist across compaction, drop the paths: frontmatter or move it to the project-root CLAUDE.md.
• Skill bodies can be truncated. Skill bodies are re-injected, but large skills are truncated to fit the per-skill cap, and the oldest invoked skills are dropped once the total budget is exceeded. Truncation keeps the start of the file, so put the most important instructions near the top of SKILL.md.

What you can do before it compacts

You can act before the automatic pass runs. The documentation lists five ways:

The commands reference says this about the commands involved:

Keeping context lean

The context-related advice from the costs documentation:

• /clear between tasks. Stale context wastes tokens on every subsequent message. Use /rename before clearing so you can find the session later, then /resume to return to it.
• Add custom compaction instructions. /compact Focus on code samples and API usage tells Claude what to preserve during summarization. You can also put this in the CLAUDE.md at the root of your project:

  # Compact instructions
  
  When you are using compact, please focus on test output and code changes

• Watch MCP. MCP tool definitions are deferred by default, so only tool names and server instructions enter context until Claude uses a specific tool. Run /context to see what is consuming space.
• Prefer CLI tools when available. Tools like gh, aws, gcloud, and sentry-cli are more context-efficient than MCP servers because they do not add any per-tool listing.
• Trim CLAUDE.md. It is loaded into context at session start. If it contains detailed instructions for specific workflows, those tokens are present even when you are doing unrelated work. Skills load on demand only when invoked, so moving specialized instructions into skills keeps your base context smaller. The documentation suggests keeping CLAUDE.md under 200 lines by including only essentials.
• Send verbose output to subagents. Running tests, fetching documentation, or processing log files can consume significant context. Delegate these to subagents so the verbose output stays in the subagent's context while only a summary returns to your main conversation.
• Preprocess data with hooks. The documentation's example: instead of Claude reading a 10,000-line log file to find errors, a hook can grep for ERROR and return only matching lines, reducing context from tens of thousands of tokens to hundreds.

For what these habits do to your bill, see our guide to saving tokens, and for cache behavior see our cache guide. This page stays on how the context itself works.

FAQ

Sources

• Claude Code: Explore the context window (what loads at startup, what survives compaction, when context fills up, /context)
• Claude Code: Commands (/context, /compact, /clear, /rewind, /autocompact, /memory, /usage)
• Claude Code: Manage costs effectively (context-control practices, custom compaction instructions)