Context Window

What a Context window is

A context window is how much text an AI model can take into account at once, measured in tokens. It covers the conversation so far, any documents supplied and the answer being written. A longer window lets one conversation run longer and lets the model work across longer documents.

The large language model page describes it as the amount of text a model can hold in view while it works: the prompt, an attached document and its own growing answer, together. That is the plain picture to keep: the model works with what is in view, and the window is the size of the view.

This page covers what is counted, why a longer window matters, what the vendors publish, why bigger is not the same as better, how a long conversation affects cost, and how a window differs from memory.

Tokens, not words

The window is counted in tokens. A token is the small chunk of text a model reads and produces one piece at a time, close to a word or a part of one. The large language model page says the same, and the running cost article uses the same unit for billing: providers bill by the amount of text a model reads and writes.

Tokens matter because they are the unit every published figure uses. A vendor that says one million tokens is giving a size, and it is only meaningful once it is turned back into something a person can picture. The Claude comparison does that on Anthropic’s own figures: a window of one million tokens is roughly 555,000 words, which is a few long books, or a large folder of contracts, in one conversation.

Everything shares one window

The part people miss is that the window is shared. The prompt page says the prompt, any attached document and the model’s own growing answer share one context window, so a longer prompt leaves less room for everything else.

That has a practical reading. The window is not only for what is pasted in. It also has to hold what the model is about to write. A request that fills most of the window with source material leaves little space for a long answer, and a very long conversation uses up room that a new document would have needed.

The AI brief page argues for giving a model the context it needs. The window is the limit on how much context there can be.

Why a longer window matters

The site’s definition gives the benefit in one line: a longer window lets one conversation run longer and lets the model work across longer documents. The means-here line adds the reason. A bigger window lets a model work across a longer document or conversation without losing track of the earlier part.

The large language model page gives a concrete case. Google states one million tokens for Gemini, extended directly into tasks such as querying a large PDF stored in Drive without splitting it into smaller pieces first. A business that regularly works with one very long document, such as a large contract or a technical manual, gets more practical benefit from a published figure like that than from a feature built around a different ecosystem.

The GenAI FAQ on research tools makes the same point from the user’s side. NotebookLM runs on Gemini, which has one of the largest context windows of the public AI tools, so it handles many long documents while staying within the sources it is given. The grounding page covers why staying within given sources matters, and a large window is what lets the sources be long.

What the published figures say

Several reviews on the site print a figure, and they do not all say the same thing.

Anthropic’s Claude 5.5 models, Sonnet and Opus, both have a one million token window. The Claude comparison adds a caution. Whether the model uses all of that well is a separate question, so test long documents before you rely on them.

OpenAI’s GPT-6 Astra is described in its review as a large language model with a one million token context window and up to 128,000 tokens of output.

Mistral Large 4 shows how figures can disagree. The review says Mistral’s own model page lists one million tokens, while an outlet reported 512,000 from the announcement and about 520,000 measured by an independent ranking. The review’s advice is the same: test long inputs before you rely on them.

Microsoft is the other kind of case. The Copilot and Google comparison says Microsoft does not publish an equivalent token figure for Microsoft 365 Copilot, tracking usage through AI credits and per-app limits instead. The review calls it a gap in what is published and not a like-for-like number to weigh against Gemini’s.

Bigger is not the same as better

A large window answers one question: how much can be held in view. It does not answer whether the model uses that material well, whether the answer is right, or whether the tool suits the work.

The Claude comparison says the first plainly: whether the model uses a million tokens well is a separate question. The hallucination page covers the second. A model that holds a whole contract in view can still sound sure and be wrong about a clause.

The large language model page covers the third. It says none of this makes one model simply better than another in the abstract. A business already living inside Microsoft 365 gets more from Copilot’s grounding in its own emails and documents than from a stated window it has no obvious use for. Choosing is a question about which product’s strengths line up with how the business works.

Context window and Memory

The two are easy to confuse, and the site keeps them apart. A context window is what a model holds in view during one piece of work. Memory is what a tool keeps between conversations.

A large window does not carry anything from last week into today. When a conversation ends, what was in the window goes with it, unless a memory feature stored something.

What happens when a job is longer than the window

Even a million tokens can be exceeded by a long enough job. The GPT-6 Astra review describes one answer. In Codex, OpenAI’s coding tool, Astra keeps notes in searchable records that carry across context windows, instead of squeezing the earlier work into a summary. The review notes that this matters for any task long enough to overflow even a million-token window, because a summary loses detail and a searchable note does not.

That is a report of one tool, and not a general rule. The useful idea is that there are two ways to deal with overflow. One is to compress what came before, which loses detail. The other is to keep it somewhere that can be searched and bring back only what is needed.

Why a long Conversation costs more

Where use is billed by text, the window has a price. The running cost article cites a published explainer on token pricing. It says that in a long conversation the earlier turns are sent again with each new one, so a conversation of twenty turns reads its own history twenty times.

That is why conversation length matters for cost and not only for quality. A long chat is not one long read. It is a pile of repeated reads, and each new turn adds to the pile. The article notes that the model is often the smallest line in a workflow’s running cost, so this is one cost among several. It is still a cost that a team can control.

Keeping a task Narrow

The running cost article’s advice is to keep the task narrow, because a narrow task keeps what the model has to read small. The same idea runs through the site’s well-scoped workflow article, which says a narrow build gives a result that can be measured.

Nothing about this is a technical trick. It is the same discipline as writing a good brief, applied to size.

A worked example

An illustration, not a case study. A business wants to ask questions about a long supplier contract. The contract fits comfortably in the window of the tool it uses, so the whole document goes in once, and the first question gets an answer that quotes a clause.

The team then tests the answers against the contract before trusting them, as the Claude comparison advises for long documents. Over the afternoon the conversation grows long, and the answers begin to feel looser. The team starts a fresh conversation, puts the contract in again, and asks the next question there, so the new question is not carrying the earlier turns.

Mix-ups worth avoiding

Four confusions come up often enough to name. The first is assuming a bigger window means a better answer, when it only means more can be held in view. The second is assuming a window is a memory, when memory is what a tool keeps between conversations. The third is comparing two tools on a figure only one of them publishes. The fourth is treating a long conversation as costing nothing, when earlier turns are read again each time.

How we use it

The workflow running cost article shows why conversation length matters for cost: providers bill by the amount of text a model reads and writes, and in a long conversation the earlier turns are sent again with each new one. Keeping a task narrow keeps what the model has to read small.

If you are choosing a tool for work that depends on long documents, a scoping conversation is a quick way to test it against your own material.

Sources

• Large language model and prompt: the window as what a model holds in view, shared by prompt, document and answer.
• Claude Sonnet 5.5 vs Opus 5.5: the one million token figure, the word equivalent and the advice to test long documents.
• GPT-6 Astra review: the window and output figures, and searchable notes across windows.
• Mistral Large 4 review: a stated figure and the reports that differ from it.
• Microsoft Copilot vs Google Workspace AI: one vendor publishing a figure and the other not.
• How much does an AI workflow actually cost to run?: earlier turns being sent again with each new one.
• What do you get with paid ChatGPT, Claude or Gemini? and Is NotebookLM better than ChatGPT for research?: longer windows on paid plans, and long documents in NotebookLM.