If I start a new conversation, does everything from the previous one completely disappear?
For typical use through the claude.ai web app or mobile app, a new conversation doesn't automatically carry over content from a previous one — each conversation has its own independent Context Window. Unless you manually copy over key points from the earlier conversation, or use a specific feature (like shared background material within a Project) to deliberately make it available, a new conversation starts as a clean slate.
This is actually a feature, not a bug: if every new conversation automatically accumulated all historical conversation content, your Context Window would fill up with irrelevant old information very quickly, running into the capacity problem described in this article even sooner. Starting fresh and manually bringing in genuinely relevant background as needed is the normal way to manage a good long-term usage experience, not a system shortcoming.
Does an uploaded document take up space in the Context Window? How is it different from typing directly?
Yes — the content of an uploaded document gets converted to tokens and counted against this conversation's capacity, and there's fundamentally no difference from typing or pasting text directly into the chat box in terms of "taking up space." A lengthy PDF or codebase can end up consuming a substantial chunk of capacity once converted to tokens.
The practical difference is efficiency: if you only need a few sections from a long document, uploading the entire document and having Claude search through it for the relevant parts uses more capacity than precisely copying and pasting just the passages you actually need. If you find yourself regularly needing to work with document collections that exceed window capacity, a better-suited approach is usually storing the content externally and feeding Claude only the relevant excerpts as needed, rather than dumping the entire batch into a single conversation every time.
Does Extended Thinking take up additional Context Window capacity?
Yes. When Claude uses Extended Thinking for internal reasoning, the resulting thought process is itself measured in tokens and also counts against this conversation's Context Window space — and this content is typically billed as output tokens, not as "free" extra thinking.
For tasks requiring complex, multi-step reasoning, this is a reasonable tradeoff — deeper reasoning generally buys more accurate answers, but it also means you'll approach the capacity limit faster, especially if you run several deep-reasoning tasks back to back within the same conversation. If you notice your conversation's capacity draining faster than expected, checking whether Extended Thinking is being triggered frequently is a direction worth investigating.
If I'm working on a long-term project, how do I actually manage the Context Window so it doesn't blow up mid-task?
The most practical habit is "clear when you switch tasks": if you're about to start work completely unrelated to the current conversation, starting a new conversation is usually better than continuing in the same one — content accumulated from the old conversation not only takes up capacity but can also interfere with Claude's judgment on the current task.
For the same task, partway through, where you need to preserve context, you can proactively trigger a summary/Compaction (if your interface supports this) to compress earlier details into a concise summary and free up room to keep going, rather than letting the conversation accumulate indefinitely until it triggers automatically or errors out. If you're working with a large codebase through Claude Code, delegating heavy file-reading work to a subtask and only bringing the genuinely needed results back into the main conversation is also a common way to control capacity consumption. The overall principle: proactively managing content usually produces a more consistent experience than passively waiting for the system to handle it.
If you've ever noticed Claude start "forgetting" details you mentioned earlier in a long conversation, or its answer quality mysteriously drop, the cause almost always points to the same thing: the Context Window has approached or exceeded its capacity. This isn't Claude selectively forgetting, and it isn't getting dumber — it's a structural capacity limit at work.
A context window is the maximum amount of text Claude can reference at once while working on your conversation, measured in tokens. It's made up of several parts: the System Prompt, every message in your conversation, any documents or images you've uploaded, and the response Claude is currently generating — all of it combined can't exceed this limit.
A more fitting analogy is "the surface area of a desk," not "how much a person's brain can remember." You can spread a lot of material out on the desk to reference, but the desk only has so much surface — once it's full, there's no room for anything new unless you clear off some of what's already there. This is also why "Claude forgot what I said earlier" usually isn't the model actively choosing to forget — it's that accumulated conversation has exceeded what the desk can hold, pushing earlier content out.
When a language model generates each word, it's actually "looking back" over the entire input to determine what word should reasonably come next. The computational cost of that "looking back" grows rapidly as input length increases, and not simply linearly — which is exactly why expanding a context window isn't as easy as "changing a setting." It involves substantial engineering work to let the model process longer input within reasonable time and cost.
Understanding this recalibrates a common mismatched expectation: it's not that "Claude should remember everything we discussed months ago" — it's that this conversation has an actual capacity limit, and once that capacity fills up, earlier content starts getting sacrificed.
This number varies by model and by which interface you're using, and it keeps shifting as Anthropic ships new models. As a rough mental conversion: about a thousand English words corresponds to roughly 800 tokens.
In practice, the window size in a claude.ai web conversation depends on which model and plan you're using; some newer models already support up to 500K tokens or more in web chat, while using Claude Code or the API, some models support windows in the range of a million tokens. Because this number updates fairly frequently, if you need to confirm the actual limit for the model you're currently using, checking Anthropic's official documentation page for the current spec is more reliable than memorizing a fixed figure.
The common understanding used to be "once capacity is full, the conversation errors out or gets cut off," but this behavior has notably changed on newer-generation models. Anthropic's official documentation states that newer models now support an automatic Compaction mechanism in certain contexts: when accumulated conversation content approaches the capacity threshold, the system automatically summarizes and compresses earlier messages so the conversation can continue without interruption — and the user's full conversation history remains preserved for the model to reference, rather than simply being discarded.
If you're using the web app and notice Claude pausing briefly, as if "organizing its thoughts," during a long conversation, that's usually this automatic content management running in the background — not a system malfunction. If you're doing long-running project work through Claude Code, you can also proactively control when this compaction happens via commands, rather than passively waiting for the system to trigger it on its own.
Here's a point that's easy to overlook: window size alone doesn't equal effectiveness. Analysis suggests that stuffing a huge window full of every available piece of data doesn't necessarily outperform a smaller, tightly focused window containing only genuinely relevant information — a 200K-Token window focused on truly relevant code sometimes outperforms a million-token window stuffed with an entire codebase, most of which never gets used. In other words, window size determines the capacity ceiling, not the quality of use — what actually drives answer quality is often how precisely relevant the content you put in actually is.
If you regularly use Claude for long-document analysis, extended code refactoring, or project discussions spanning several weeks, understanding the context window can save a real amount of wasted back-and-forth time: rather than repeatedly asking "didn't you say..." in the same near-capacity conversation, it's usually more efficient to start a fresh conversation and re-supply the genuinely necessary background concisely — this often produces more consistently good results faster than continuing to wrestle with an old conversation. If you're building a long-running application through the API or Claude Code, understanding the relationship between window size and cost also helps you choose more wisely between "dumping everything in at once" and "providing relevant content precisely, in batches" — often the detail that decides whether a long-conversation application actually feels good to use.