How to Recover a Frozen Claude Chat with Large Context

Mar 26, 2026

I was working on a complex project with Claude, layering in code reviews, architectural decisions, and implementation details across dozens of messages. Then it happened—Claude stopped responding. Not an error message, just… frozen. The conversation had grown too large.

If you’ve experienced this, you know the panic. All that context, all those decisions, seemingly locked away in an unresponsive chat. Here’s how I recovered mine.

What “Frozen Context” Actually Means

When a Claude conversation accumulates enough messages and data that it approaches the context window limits, the conversation can become “frozen.” Claude becomes unresponsive, slow, or returns errors. This typically happens when:

Context exceeds 20% of the 1M token limit on Opus
You’re rate-limited or have exhausted your usage tier
The sheer volume of cached context makes operations prohibitively expensive

The frozen state doesn’t mean your data is lost—it means the conversation has become unwieldy and needs condensing into a portable format.

The Recovery Process

Step 1: Check Your Usage Status

Before attempting recovery, verify you haven’t hit your usage cap. If you’re capped, wait for your usage to refresh, or consider pay-as-you-go if you’re on a tier with strict limits.

Step 2: Extract the Context

Open the frozen chat and use this direct prompt:

Summarize this conversation and output it to a file I can download. Include all key decisions, code changes, architectural choices, and any important context I'll need to continue this work in a new chat.

Important: This operation will spike your usage because Claude must re-cache the entire context to process the summary request. Accept this cost as the price of recovery.

Step 3: Create Portable Context

Once you have the summary file:

Download and save it locally
Review the content for accuracy and completeness
Remove non-essential information (chit-chat, tangents)
Structure it for easy reference in future chats

Step 4: Curate Further (Optional)

If the summary is still too large, use another AI model to extract critical information:

Below is a conversation summary that's too large for practical use. Extract only:
1. Key architectural decisions and their rationale
2. Critical code patterns or implementations agreed upon
3. Important constraints or requirements
4. Any unresolved questions or next steps

Remove all filler, pleasantries, and redundant information. Output a condensed version suitable for continuing this work.

You can also manually edit to keep only decision-relevant content, or split into multiple topic-specific files.

Step 5: Start Fresh with Portable Context

Begin a new Claude conversation and upload the portable context file. Use this prompt:

I'm continuing work from a previous conversation. The attached file contains the essential context from that session. Please review it and confirm you understand where we left off, then I'll provide my next request.

Why Direct Use of Frozen Context Fails

Using a frozen conversation directly causes issues because:

┌─────────────────────────────────────────────────────────────┐
│                    FROZEN CONTEXT CHAIN                      │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   Your Request ──► Process ALL Context ──► Generate Response  │
│                          │                                  │
│                          ▼                                  │
│              ┌─────────────────────┐                        │
│              │  800K+ tokens of    │                        │
│              │  cached context     │                        │
│              │  must be processed  │                        │
│              │  for EVERY request  │                        │
│              └─────────────────────┘                        │
│                          │                                  │
│                          ▼                                  │
│              Timeout / Error / Extreme Slowness             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Token cost: Every response must process the entire accumulated context
Cache limits: Large contexts may exceed caching capabilities
Performance: Response times degrade significantly
Reliability: Higher chance of errors and timeouts

Prevention: The 20% Rule

Based on community recommendations from the Reddit discussion, here’s the practical guideline:

“If you get over 20% context on Opus, start a new chat.”

This isn’t arbitrary. At 20% of a 1M token context (roughly 200K tokens), you’re approaching the point where:

Caching becomes expensive
Response quality can degrade
You’re closer to hard limits

Proactive Compaction Strategy

Instead of waiting for a freeze:

Monitor context usage in the Claude interface
At 15-20%, summarize the conversation yourself or ask Claude to create a checkpoint summary
Archive the summary and start fresh
Upload the summary to the new chat when needed

Create a checkpoint summary of our conversation so far. Include:
- Decisions made and their rationale
- Code written or modified
- Current state of the project
- Next steps we identified

Format it for easy reference in a future conversation.

The Trade-off: Usage Spikes vs. Lost Context

Here’s the honest assessment:

Approach	Usage Cost	Context Preservation	Risk
Let it freeze	Low	High risk of loss	Data loss
Extract immediately	High spike	Full preservation	Temporary usage cap
Proactive compaction	Distributed	Full preservation	Requires discipline

The extraction method costs more upfront but guarantees you keep your work. The preventive approach spreads the cost but requires vigilance.

Real-World Recovery Scenario

I had a conversation with approximately 847K tokens of context—code reviews, architectural debates, implementation details for a multi-service system. Claude froze mid-response on a critical implementation question.

The extraction prompt returned a 47KB markdown file. I reviewed it, removed about 30% that was conversational filler, and uploaded the cleaned version to a fresh chat. The new conversation started at roughly 3% context usage instead of 84%.

Original frozen chat: ~847K tokens (84%+ of context)
Extraction summary: ~47KB markdown file
After curation: ~33KB portable context
New chat context: ~3% usage

Recovery time: ~15 minutes (including review and cleanup)
Usage spike: One-time re-cache of full context

Key Takeaways

Frozen doesn’t mean lost. Your context is recoverable with the right extraction prompt.
Accept the usage spike. Re-caching the full context costs more, but it’s the price of recovery.
Curate aggressively. Remove everything non-essential. Portable context should be dense with signal, not noise.
Prevent with the 20% rule. Don’t wait for a freeze. Compaction at 20% is far cheaper than recovery at 80%+.
Use checkpoints. For long-running projects, create checkpoint summaries every 10-15% context growth.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!