What is a Context Window?

You’re three hours into a Claude session. You set the tone at the start — “write like a tired British science writer, no exclamation marks, short sentences.” It nailed it for the first hour. Now? Exclamation marks everywhere. The voice has drifted into corporate cheerleader.

The AI didn’t get bored. Your instructions literally scrolled out of what it can read.

That’s the context window. It’s the load-bearing concept behind almost every AI quirk you’ll run into.

What it actually is

Every large language model has a fixed working memory, measured in tokens (roughly three-quarters of a word — “unbelievable” is one token, “un” + “believ” + “able” is three). The model can only “see” the tokens currently inside its window. Anything outside it might as well not exist.

Inside the window at any moment:

• The system prompt (instructions the platform set, often hidden from you)
• Any custom instructions you added (e.g. a project’s CLAUDE.md or a custom GPT’s persona)
• Files you uploaded or pasted in
• The full conversation history, including every reply the AI has already given you
• Your latest message

The model doesn’t have a database it queries. It doesn’t have notes. It only has what’s currently in the window. When the window fills up, the oldest content drops out the back.

How big are they?

This number has exploded in the past three years. Rough comparison of what’s been shipped:

• GPT-3.5 (2022): 4,000 tokens. About 3,000 words. A long blog post would barely fit.
• GPT-4 (2023): 8,000–32,000 tokens.
• Claude 2 (2023): 100,000 tokens. ~75,000 words. A short novel.
• Claude 4 / Claude Sonnet 4.6 (2025): 200,000 standard, with a 1-million-token tier available. Roughly 750,000 words — about three times the length of War and Peace.
• Claude Opus 4.7 (2026): 1,000,000 tokens (1M) in beta — the current frontier for production-deployable context.
• GPT-5.5 / Gemini 2.5 Pro (2026): 1M-class context standard. Long-context is now the baseline rather than the exception.
• Gemini 1.5 / 2 Pro: 1–2 million tokens.

If you’re comparing models, the context window is one of the most consequential specs. A model with a 200K window can hold an entire codebase plus a long brief. A model with 4K cannot.

What actually eats your window

Window math is the difference between an AI that stays sharp and one that quietly degrades:

• Pasted documents. A fifty-page PDF can be 30,000+ tokens — a meaningful chunk of even a 200K window, gone before your first question.
• Long replies. The AI’s own answers count toward the limit too. A model that writes a thousand-word response just spent ~1,300 tokens of its own window.
• Conversation length. Every back-and-forth accumulates. Hour-three sessions look very different from hour-one sessions internally, even if you’ve forgotten everything you discussed.
• Tool calls. If the AI is using tools (web search, code execution, MCP servers), the tool inputs and outputs land in the window.

Strategies that actually help

Once you understand the window, a lot of “why is this AI being weird” problems get answers:

1. Re-prime mid-session. If voice or rules drift, paste the key instructions again. They re-enter the window and bias the next replies.
2. Start fresh sessions on purpose. A new chat starts at zero tokens. You lose context, but you also lose accumulated noise.
3. Use a project structure. Claude Projects, custom GPTs, and NotebookLM all let you attach a fixed source set that’s always in the window — instructions and files that don’t drift out.
4. Summarise instead of pasting. A 200-word summary of a meeting is better than the 8,000-token transcript if you only need the gist.
5. Watch for the lost-in-the-middle effect. Research has shown that even when content fits in the window, models pay less attention to material in the middle of a long context. Important instructions go at the start or the end, not buried halfway down.
6. Compact when supported. Tools like Claude Code and Anthropic’s Cowork mode compress old turns into summaries to free up window space — a feature, not a bug.

The myth: bigger isn’t always better

A 1-million-token window sounds like the answer to everything. It isn’t. Three caveats:

• Cost. You pay per token in and per token out. A million-token prompt is expensive, every single call.
• Latency. The bigger the window in use, the slower the response. Big context = slow first token.
• Attention dilution. A model with a million-token window doesn’t necessarily reason as well over a million tokens as it does over fifty thousand. More room means more places for important details to get diluted.

The right window size is the smallest one that holds what you need. Not the biggest one available.

When to care

Care a lot if you’re: doing long-form research, writing book-length manuscripts, working with codebases, running multi-hour sessions, or building anything with the API where token cost matters.

Care less if you’re: asking quick one-shot questions, drafting short emails, or doing anything where each session is bounded and short.

External reading

Anthropic’s official explainer: Context windows. For a more general primer: Wikipedia: Context window. (Grokipedia doesn’t have a dedicated entry yet.)

Related

• What is CLAUDE.md? — how to keep your instructions inside the window automatically.
• What is Claude Projects? — fixed-source containers that don’t drift out.
• What is Claude Code? — and why its compaction step matters.
• What is NotebookLM? — a different shape of the same idea: chat with a fixed corpus.
• What is MCP? — how external context gets pulled into the window on demand.
• What is Cowork (in Claude)? — Anthropic’s compaction-aware long-session mode.