If Claude just told you "Claude hit the maximum length for this conversation" or "This conversation reached its maximum length," or ChatGPT said "The conversation is too long, please start a new one" (newer wording: "You've reached the maximum length for this conversation, but you can keep talking by starting a new chat"), here is the short version: the thread is now permanently read-only, everything written in it still exists, and the model's working state is gone. Part of what you care about is salvageable. Part is not, and I will be specific about which is which.
People have been hitting this wall since 2023, often after weeks of work inside a single thread, and the official fix on both platforms still amounts to "start a new chat." This guide covers what the error means, what to do in the first five minutes, and how to set things up so the next one costs you nothing.
Why the wall is hard
Every time you send a message, the model rereads the entire thread: every message, pasted file, artifact, and tool result. All of it has to fit inside the context window, the fixed buffer the model computes over. For Claude that is 200K tokens on all models and paid plans, with 500K on some Enterprise models. ChatGPT ties the window to your plan; OpenAI's plan pages list 32K tokens on Business and 128K on Pro and Enterprise.
When the next exchange can no longer fit, the app stops accepting input. Nothing overflows to disk, because the window is a property of how the model computes, not a storage quota someone could raise for you. Anthropic's official troubleshooting documents the compose-time variant ("Your message will exceed the length limit for this chat. Try attaching fewer or smaller files or starting a new conversation.") and its advice tops out at chunking your inputs, summarizing, and starting fresh. OpenAI's in-product message says the same thing in fewer words.
What the dead thread can still do
The conversation is frozen, not deleted. It stays in your sidebar and you can scroll, read, and copy all of it, including artifacts and canvases.
| After the wall | Claude | ChatGPT |
|---|---|---|
| Read and copy the whole thread | Yes | Yes |
| Export it | Settings > Privacy, web or desktop only | Settings > Data Controls > Export, zip arrives by email |
| Reference it from a new chat | Pro and above, via chat search | With reference chat history enabled |
| Send another message | No | No |
The third row matters most. In a new Claude chat you can ask "find our conversation about X and continue from there," and Claude will search the old thread. ChatGPT's chat-history memory works similarly. Both retrieve fragments, not the full thread, so treat them as a finding aid rather than a resurrection.
What is gone for good
The thread did not lose your data. It lost the ability to continue. That distinction decides what you should mourn and what you should not.
Gone: the model's in-flight understanding. The twenty corrections that turned a generic draft into a sharp one live diffused across the whole history, and no summary or memory retrieval carries all of them forward. Gone too is anything mid-generation: an artifact the model was halfway through rewriting stays at whatever state the last completed turn left it in.
There is no official recovery path that reopens a maxed-out conversation on either platform, no support ticket that extends it, and the consumer apps expose no equivalent of the API's compaction. If a deliverable exists only as a half-finished artifact in that thread, the recoverable part is whatever text you can copy out of it today.
Triage: the first five minutes
Do these in order, while everything is still in front of you.
- Copy out the deliverables. Open each artifact or canvas, copy the latest version into a file on your machine. Do this before anything clever.
- Try editing your last message. Edits replace the final exchange instead of appending to it, so on Claude you can sometimes swap your last prompt for "write a handoff brief of this conversation" and get one more response out of the dead thread. The community guide that popularized this covers the details. It fails when the history alone already fills the window, so treat it as a free attempt, not a plan.
- Run a data export. Claude exports from Settings > Privacy on web or desktop; ChatGPT emails you a zip with your full history, link valid for 24 hours.
- Open a new chat and point it backwards. On Claude Pro and above, ask it to search the old conversation. On ChatGPT, chat-history memory can recall pieces of it.
The handoff brief, written before the wall
The better version of step 2 happens early. When a long thread starts feeling heavy, ask for a handoff brief while there is still room: current state of the work, decisions made and why, rejected approaches, open questions, exact next steps, and a full copy of any artifact in progress. Paste that brief at the top of a new conversation, or into project knowledge, and continue.
Be clear-eyed about the limits. A brief is a compression, and compression is exactly where the negotiated detail dies; the new chat starts knowledgeable but not calibrated. It also depends on you noticing the wall coming, which nobody does on the thread that matters. The handoff brief is damage control. The real fix is in the next two sections.
What has actually shipped (status: June 2026)
Anthropic has context compaction that auto-summarizes older history as a conversation approaches the limit, but it is an API beta (header compact-2026-01-12) for developers, not something the Claude app exposes.
The consumer side did get one real improvement: on paid plans with code execution enabled, Claude now automatically summarizes earlier messages when a conversation approaches the limit, and the docs state the full chat history is preserved so Claude can still reference it. Free-plan users, and anyone without that feature enabled, still hit the hard wall.
OpenAI documents no equivalent for ChatGPT. Memory and chat-history referencing help a new conversation pick things up, but nothing in the help center extends a single thread past its window. The wall is smaller than it was in 2023, and it is still there.
Prevention that actually works
Every mitigation above shares a weakness: it tries to save the conversation. The reliable move is to stop letting deliverables live only inside one.
Checkpoint outputs into durable files as you go. The moment a draft, schema, plan, or dataset gets good, move it somewhere that survives the thread. Three places qualify. Project files: knowledge uploaded to a Claude Project is available across every chat in that project, and notably, chats in a project do not share context with each other unless you put the material into project knowledge, so this is the mechanism, not a nicety. Local files, if you work with a desktop agent that can write to disk. Or a workspace the agent writes to directly over MCP, so checkpointing happens as a side effect of the work instead of as a chore you remember.
Then treat every long thread as disposable, because it is. When the wall comes, you lose a transcript of negotiation, not the work.
A session, not a shelf
The deeper problem is that chat interfaces store the artifact and the conversation that produced it in the same stream, and the stream is built to forget. I wrote up the full argument in The Scrollback Graveyard; the maximum-length error is just that failure mode with an abrupt ending.
This is also the problem I build against. Caipi is my product: a hosted workspace that agents like Claude and ChatGPT write into over MCP, so pages, documents, and small apps land at a stable URL instead of in scrollback. When an agent works that way, a conversation hitting its maximum length costs you a session, never a deliverable. If that failure has bitten you more than once, caipi.ai is the shape of fix I would look for, mine or anyone else's.
Either way, the rule stands on its own: the chat is where work happens, and a file is where it lives.
Platform behavior described here was checked against the official Claude and OpenAI documentation in June 2026.