Context Window: An AI Model's Working Memory

A context window is the amount of text a language model can look at while it writes its next reply: your prompt, the earlier conversation, files it has read and its own earlier output. It is the model's working memory for one session, separate from what it learned in training. Current frontier models list windows from hundreds of thousands to about a million tokens. Checked 31 October 2026.

At a glance

The definition

Anthropic's glossary describes the context window as the amount of text a language model can look back on and reference when generating new text. It is different from the large corpus the model was trained on and acts as working memory. A larger window lets the model handle more complex and lengthy prompts, while a smaller one limits long prompts and coherence over extended conversations.

Claude Code's glossary applies the idea to a coding session. The window holds the conversation history, file contents, command outputs, CLAUDE.md, auto memory, loaded skills and system instructions. As you work it fills until compaction summarises it, and you can run /context to see what is using space.

Tokens, briefly

Models read tokens, not letters or words. A token is a piece of text, often part of a word. Providers count them differently, so the same page can be a different number of tokens in different models. Prices and limits are quoted per token, usually per million. Do not convert tokens to words with a fixed rule when planning a budget; use the usage numbers an API returns for your own text. Anthropic's token counting docs give a concrete case: Claude 4.7 and later models use a newer tokenizer that produces about 30 percent more tokens for the same text than earlier models, with the exact increase depending on the content.

Context sizes on this site

All figures below come from our model pages, which read vendor pages on 31 October 2026.

See Claude models, GPT models, Mistral models and Qwen models. The listed size is a maximum. What you can use in practice depends on the product, the plan and the settings.

What fills the window

In a coding agent the window fills faster than people expect. Claude Code's context explainer lists what loads before you type anything: CLAUDE.md, auto memory, MCP tool names and skill descriptions. After that:

• File reads. Each file Claude opens enters context in full.
• Command output. Test logs and build output can be long.
• Tool results. A search or a web fetch returns text that stays.
• Your messages and its replies. The whole conversation is resent each turn.
• Rules and hooks. Path-scoped rules load next to matching files, and hook output can add text.

Worked example (made-up numbers). Say a session starts with 6,000 tokens of instructions and tool names. Claude reads ten files at 3,000 tokens each, 30,000 in all. Three test runs print 8,000 tokens each, 24,000 more. The conversation adds 10,000. The total is 70,000 tokens. On a 200,000-token window you are at 35%. On a 1,000,000-token window you are at 7%. Either way, each new turn pays to resend all 70,000, which is why long sessions cost more per turn than short ones. See Claude API pricing for the per-token rates.

What happens when it fills

Tools differ. In Claude Code the answer is compaction: automatic summarisation of the conversation as the window approaches its limit, or manually with /compact, optionally with a focus such as the API changes. The docs say what survives:

The last row explains a common complaint: a rule that you said in chat disappears. The cure is to put lasting rules in CLAUDE.md or AGENTS.md.

Bigger is not automatically better

A big window removes one problem, running out, and adds others.

• Cost. You pay for every token you send each turn.
• Focus. A model searching 800,000 tokens for the relevant line can miss it. Vendors test long-context recall, and results vary by model. NVIDIA's table for its Nemotron Ultra, for example, highlights its long-context score as the strength. See Nemotron models.
• Speed. Longer inputs mean slower first responses.
• Noise. Old, irrelevant text can pull the model off course.

Good practice is to give the model what it needs and little else.

Ways to save context

For add-ons, the MCP servers entry explains why each connected tool has a context cost, and Claude Code's docs say a command-line tool such as gh can be more context-efficient than a server.

Context window and running models yourself

If you host a model, the window affects memory as well as price. The attention state a model keeps for each token (its key-value cache) grows with the window and sits in GPU or system memory, on top of the weights. A model that loads fine at a short window can fail at a long one. Plan for both, and see GPU requirements for LLMs and quantization. The memory per token depends on the model's architecture, so read the model card for your model.

Context window vs memory vs RAG

A bigger window does not replace retrieval for large knowledge bases: you still pay per token and focus can slip. See MCP vs RAG for how tools and retrieval differ.

Our take

Treat the window like a desk. A bigger desk helps, and a messy one still slows you down. Look at the limit on the model page, keep standing instructions short, push noisy work into subagents and put rules that must survive into a file. We state sizes from vendor pages on the check date, and they change with each release.