A context window is everything an AI model can see while it writes its next reply: your messages, its earlier answers, any files you pasted, any instructions the app adds, and the reply itself as it is being generated. It is measured in tokens, it has a hard ceiling, and anything outside it does not exist as far as the model is concerned.
That is why a chatbot can nail a detail at message three and fumble it at message forty. Sometimes the detail has fallen out of the window. More often, and more annoyingly, it is still in there and the model has stopped paying close attention to it.
*This explainer is built from vendor documentation and published research, checked on 13 September
- It is not based on our own benchmarking. Window sizes change often, so the dates are there to
tell you when this page goes stale.*
The short version
- The conversation so far, anything you paste and the reply all draw on one shared budget.
- Current flagship models from Anthropic, OpenAI and Google are documented at around a million tokens.
- Quality slips well before the window is full, and the vendors say so in their own docs.
- In a long chat, the fix is usually less context, better placed.
What a token is, with real numbers
Models do not read words. They read tokens: chunks of text that are often a whole short word, sometimes part of a longer one, sometimes a single character. Google’s Gemini documentation gives the rule of thumb most people use: a token is about four characters, and 100 tokens is roughly 60–80 English words.
Here is that rule applied to something real. Our explainer on why AI makes things up is 1,485 words, about 9,400 characters in its source file.
| Method | Estimate for that article |
|---|---|
| About 4 characters per token | roughly 2,350 tokens |
| 60–80 words per 100 tokens | roughly 1,860–2,480 tokens |
So, somewhere around 2,000 to 2,500 tokens. Both figures come from a rule of thumb, not a tokenizer, and the rule is stated for English. Tokenizers also differ between model families: the researchers behind the study covered below found that Llama’s tokenizer turned the same text into longer sequences than the other models they tested did. If the exact number matters, use the counting tool for the model you are actually using. Anthropic, for example, offers a token counting API.
The arithmetic scales the way you would expect. A one-million-token window holds roughly 400 articles that size. Google’s long-context guide puts a million tokens at around eight average-length English novels, or 50,000 lines of code.
What counts against the window
Everything, including text you never see. Anthropic’s context window documentation spells it out for its API: the system prompt, every message, tool results, images and documents, tool definitions, and the output the model generates for that turn, including any extended thinking.
Three consequences are worth knowing.
The whole conversation goes back in every turn. Each reply is generated from the history so far plus your new message. Unless the app trims it, message forty carries messages one to thirty-nine along with it. On the API, you pay to have all of it read again.
The reply takes space too. The window is shared between what goes in and what comes out.
Apps can add text of their own. If you use a chat app rather than the API, it may add a system prompt, and that counts against the same budget.
How big windows are right now
Checked against each vendor’s documentation on 13 September 2026:
| Vendor | What the documentation says |
|---|---|
| Anthropic | 1M tokens for current models including Claude Opus 5, Sonnet 5 and Fable 5.1; 200k for some older models such as Sonnet 4.5 |
| OpenAI | 1.05M tokens for GPT-6 Astra and the GPT-5.6 Sol, Terra and Luna models, with up to 128K output tokens |
| “1 million or more tokens” for Gemini models; the guide does not break this down per model |
Two caveats. These are developer API figures. Chat apps run on the same models but manage the window their own way, and do not always publish how; Anthropic’s documentation notes, for instance, that chat interfaces such as claude.ai can drop the oldest material first as a conversation grows. And the ceiling is not the limit that bites. That comes much earlier.
Full is not the problem. Crowded is.
The intuitive picture is a bucket: fine until it overflows. A better one is a desk. Long before it is covered, the page you need gets harder to find.
Anthropic’s documentation says as much. It warns that more context is not automatically better, and that accuracy and recall degrade as the token count grows, a problem it calls context rot. Google’s long-context guide makes a similar admission: pulling one fact out of a huge input works well, but when you need several specific pieces of information, accuracy drops and varies widely.
Anthropic’s engineers give the underlying reason (September 2025). In a transformer, every token attends to every other token, so n tokens means n² pairwise relationships. The longer the context, the thinner that attention is stretched.
The middle is the worst place to put anything
The best-known evidence is Lost in the Middle, a study by Nelson Liu and colleagues at Stanford, UC Berkeley and Samaya AI, first posted in July 2023 and published in Transactions of the Association for Computational Linguistics in 2024. They gave models 10, 20 or 30 documents, only one of which contained the answer, and moved that document around.
Accuracy traced a U shape: best when the answer sat at the very start or the very end, worst in the middle. In their tests, GPT-3.5-Turbo did worse with the answer buried mid-context than it did with no documents at all, answering from memory (56.1% accuracy). And versions of the same models with extended windows often performed no better than their shorter-window counterparts. A bigger window did not mean better use of it.
The caveat that matters: those were 2023 models with windows between 4K and 100K tokens. Today’s models are far more capable, and we do not have a like-for-like rerun to point you to. What we do have is Anthropic and Google both still warning, in current documentation, that performance slips as context grows. Treat “do not bury it in the middle” as a sensible default rather than a law.
What this looks like in a chat, and what to do
| What you notice | What is probably happening | What to do |
|---|---|---|
| It ignores an instruction you gave early on | The instruction is far back in a long history, or the app has trimmed it | Restate it in your latest message |
| It contradicts something it said earlier | Early turns trimmed, summarised, or simply not attended to | Start a new chat with a handoff note (below) |
| It answers from general knowledge instead of your document | The relevant passage is buried in a long paste | Paste only the section that matters and ask about that |
| Answers get vaguer the longer the thread runs | A lot of stale, half-relevant history competing for attention | New chat, less material |
| An error saying the message or file is too long | You have hit the hard ceiling | Split the material and work through it in parts |
Habits that help
Put the important part first or last. Material in the middle, your actual question at the end. If an instruction matters, restate it right before you ask.
Give it less. Paste the three pages that matter, not the 80-page report. It is the same idea as giving the model the material it needs, with the emphasis on needs.
Start fresh on purpose. When a thread has wandered, a new chat with a tight summary usually beats pushing on. Agent builders do this automatically (Anthropic calls it compaction), and it is one reason agents run into trouble as their context fills up.
Keep the notes outside the chat. For work that spans days, keep a short running document of decisions and facts, and paste it in at the start of each session. Anthropic’s engineering team recommends the same pattern, structured note-taking, for long-running agents.
Double-check anything from far back. If a detail came from forty messages ago, the model may be working from a trimmed or blurry version of it, which is exactly where confident reconstruction takes over from reading.
A handoff note you can reuse
We're going to continue this in a new chat. Write a handoff note I can paste there.
- Goal: one sentence on what we're trying to produce.
- Decisions made: a bullet list, each with the reason in a few words.
- Facts and figures we're relying on: exact values, and where each one came from.
- Constraints: format, tone, length, anything I asked you to avoid.
- Open questions: what is still undecided.
- Next step: the single next thing to do.
Keep it under 300 words. Leave out anything we tried and abandoned,
unless it explains a decision.To adapt it: for a writing project, add the current outline; for code, add the files changed and why. Then read the note before you paste it. It is a summary written by the same model, so check the “facts and figures” lines against your originals. In the new chat, put the note first and your next request at the end.
Bigger windows are useful, not magic
A million-token window genuinely changes what is possible: a whole codebase or a long contract can go in at once. But the window decides what the model can see, not what it will notice. The skill is the same at 8K tokens and at a million: choose what belongs in front of the model, and put the part you care about where it is hardest to miss.
The thing worth remembering
When a long AI conversation starts going wrong, the answer is rarely to give it more. Give it less, put what matters at the start or the end, and when in doubt, start a new chat with a good summary.