Auto-compact keeps your sessions running indefinitely by intelligently summarizing conversations when you approach context limits. Since v2.0.64, compacting is instant—no more waiting. Your work continues seamlessly with all important context preserved.

How Auto-Compact Works​

When your conversation approaches the context window limit, Claude Code automatically:

1. Analyzes the conversation to identify key information worth preserving 2. Creates a concise summary of previous interactions, decisions, and code changes 3. Compacts the conversation by replacing old messages with the summary 4. Continues seamlessly with the preserved context

Three Context Management Options​

• Auto-Compact (Default): Automatic summarization when approaching limits. Best for most users who want hands-off context management
• Manual Compact (/compact): You control when and how to summarize with specific preservation instructions
• Clear (/clear): Starts a completely fresh conversation with no context preservation
• MCP Server Optimization: Disable unused MCP servers to free context tokens before needing to compact (v2.0.10+)

Manual Compact Examples:

# Basic compact
/compact

# Compact with specific preservation instructions
/compact only keep the names of the websites we reviewed

# Compact preserving code patterns
/compact preserve the coding patterns we established

Controlling Auto-Compact​

You can check or change auto-compact settings in your session:

/config

This shows whether auto-compact is enabled and your current context usage.

What Gets Preserved​

Auto-compact typically preserves:

• Recent code changes and file modifications
• Project structure and important architectural decisions
• Ongoing task context and current objectives
• Key patterns and naming conventions established
• Important configuration and setup information

What Gets Summarized​

Auto-compact condenses:

• Detailed explanations that are no longer immediately relevant
• Debugging sessions that have been resolved
• Exploratory discussions that didn't lead to code changes
• Historical context that's no longer needed for current tasks

Manual Compact Strategies​

I use manual compact when I want control over what gets preserved:

• Before major changes: /compact preserve current architecture decisions
• After debugging: /compact keep the solution we found, remove debugging steps
• Project transitions: /compact focus on the new feature requirements
• Proactive context management: Disable unused MCP servers with /mcp or @server-name disable before compacting to maximize available context

The real strategy is to manually compact at strategic times rather than letting auto-compact happen randomly. When auto-compact triggers automatically, it can disrupt your workflow and mess up your current setup. I use /compact at natural breakpoints when I control what gets preserved.

Preventing Compaction: Before resorting to compaction, use /context to identify MCP servers consuming context space but not actively needed. Disabling unused MCP servers can free up significant context space, potentially avoiding the need to compact altogether.

See Also: Context Window Depletion|Claude Code Usage Limits|Memory Management|Context Inspection