A context window is the maximum amount of text, measured in tokens, that a large language model can process in a single request, covering your prompt, any documents you attach, the conversation history, and the model's response combined. Frontier models have converged around 1 million tokens, but the advertised number rarely tells you what you'll actually get, or what the model can actually use well.

This guide defines the term, compares the current LLM context length for every major model, and explains why a bigger window doesn't automatically mean better answers.

What Is a Context Window?

A context window is the working memory of an LLM: the total number of tokens the model can attend to when generating a response. Everything competes for that space: 

• system instructions
  
  

• your prompt
  
  

• uploaded files
  
  

• prior turns in the conversation
  
  

• tool outputs
  
  

• and the reply itself

Once the window is full, something has to be dropped, summarized, or the request fails.

A token is a chunk of text, roughly three-quarters of an English word on average. This means a 1M-token window holds around 750,000 words: several full-length novels, a mid-sized codebase, or months of chat history in one request.

How Tokens Map to Real Content

Rough conversions for planning purposes:

• 128K tokens: ~96,000 words; a dense technical book or a long legal contract
  
  

• 200K tokens: ~150,000 words; roughly 500 pages of text
  
  

• 1M tokens: ~750,000 words; an entire repository, a document archive, or a year of conversation
  
  

• Code: budget higher; symbols and whitespace tokenize less efficiently than prose

Input, Output, and Reasoning Tokens Share One Budget

The model's response draws from the same budget, and on reasoning models, so do "thinking" tokens. Anthropic's context window documentation notes that thinking tokens count toward the window like any other input on current models. This means a "1M window" with a 128K max output leaves you closer to ~870K of practical input space on a generation-heavy task.

LLM Context Window Comparison (September 2026)

Here's the current LLM context window for every major production model. All figures are API-level maximums from official documentation.

Freshness note: Last verified September 2026 against provider documentation. Model lineups changed three times in the past six months alone. We re-verify this table quarterly.

Firstly, the newest model isn't always the biggest: xAI's flagship Grok 4.6 carries a smaller window (500K) than the older Grok 4.3 (1M) and Grok 4.20 (2M), because window size is a deliberate product decision. 

Secondly, output caps vary more than input caps. Gemini's 64K output ceiling is half of what OpenAI and Anthropic allow, which matters for long-form generation.

Context Windows by Provider

GPT-5 Context Window (OpenAI)

GPT-5 launched at 400K tokens, GPT-5.5 moved to 1M via API, and the current GPT-5.6 models support 1,050,000 tokens with 128K max output. The 1M window is also available on Amazon Bedrock for enterprise deployments.

OpenAI's model documentation notes that prompts over 272K input tokens are billed at 2x input and 1.5x output for the full request. For high-volume workloads, that threshold, not the 1.05M ceiling, is the number to engineer around.

Claude Context Window (Anthropic)

Claude Fable 5.1, Opus 5, and Sonnet 5 all support a 1M-token context window, with 128K max output. Notably, Sonnet 5's 1M window is the default with no smaller variant. Anthropic dropped the beta headers and usage-tier gating from earlier generations. Haiku 4.5 remains the 200K speed tier. On paid claude.ai plans, the consumer apps also expose the 1M window on current models, with automatic compaction when conversations run long.

Gemini Context Window (Google)

Gemini 3 models support a 1M-token input window with up to 64K output, and the flagship Gemini 3.1 Pro processes text, images, audio, and video inside that budget, the strongest multimodal window on the market. Google pioneered this territory. Gemini 1.5 Pro's 2M-token window was the industry's high-water mark back in 2024, before the rest of the field caught up to seven figures.

Grok Context Window (xAI)

Grok is the outlier where model number and window size have decoupled. Grok 4.3 offers 1M tokens and Grok 4.5 ships 500K, while the current flagship Grok 4.6 also carries 500K and the older Grok 4.20 tops the lineup at 2M. xAI sized its coding-focused flagships around what fits a mid-sized repository rather than chasing the biggest number. If your workload genuinely needs xAI's largest window, you point at Grok 4.20, not the latest release.

Why the Advertised LLM Context Length Isn't What You Get

The spec sheet number is the API maximum under ideal conditions. In practice, four things shrink it:

• Consumer app tiers: Chat interfaces enforce smaller working contexts than the API, scaled by subscription level. The model is capable of more; the product limits it.
  
  

• Agent harness defaults: In July 2026, OpenAI cut Codex's default GPT-5.6 context from 372K to 272K tokens (a config change, not a model change) triggering earlier compaction in long coding sessions. Third-party tools like Cursor set their own caps per model.
  
  

• Pricing thresholds: OpenAI's 2x long-context multiplier at 272K and xAI's tiered long-context rates mean the economic window is smaller than the technical one.
  
  

• Reserved overhead: System prompts, tool definitions, and output budgets are pre-committed before your content gets a single token.

Before architecting around a model's headline window, check three numbers: the API max, your harness's default cap, and the pricing threshold. They're often three different figures.

Why a Bigger Context Window Doesn't Mean Better Answers

Models don't use their windows uniformly. Chroma's context-rot research evaluated 18 state-of-the-art models and found that reliability degrades as input length grows, even on tasks as simple as retrieval and text replication, and even in models carrying million-token windows. Performance dropped consistently when irrelevant context was added, well before any window was technically full.

This phenomenon is called context rot, and it has its own playbook of fixes.

The failure modes are well documented:

• Lost in the middle: Models attend most reliably to the beginning and end of the context; information buried in the center of a very long input is disproportionately missed. A 2026 benchmark of GPT-5, Grok 4, and Gemini found newer models have largely improved on middle-of-context retrieval — yet classification accuracy still collapsed to roughly 50-53% once fragmented inputs passed ~70K tokens, far below any window limit.
  
  

• Distractor sensitivity: Chroma found that plausible-but-wrong information in the haystack degrades accuracy far more than obviously irrelevant filler, precisely the kind of noise real documents contain.
  
  

• Noise accumulation in agents: Long-running agents pile up search results, dead ends, and tool output. Every irrelevant token in the window dilutes attention on the tokens that matter.

This means the question that actually determines output quality isn't "how many tokens can I send?" It's "what's the signal-to-noise ratio of what I'm sending?" A tightly curated 30K tokens will beat a sloppy 500K dump on most real tasks and cost a fraction as much.

Context Window Management: Where the Real Work Starts

If capacity is cheap and attention is scarce, context window management becomes the discipline that separates working AI systems from unreliable ones. The core moves:

1. Retrieve, don't dump: Pull only the relevant slices of your data into the window instead of pasting everything and hoping.
   
   

2. Position deliberately: Put critical instructions and facts at the start and end of the prompt, where attention is strongest.
   
   

3. Compact aggressively: Summarize stale conversation history and drop spent tool outputs before they rot the context.
   
   

4. Budget the window: Reserve explicit token allocations for system instructions, retrieved data, history, and output rather than letting them fight for space.

These strategies and the broader practice of designing what goes into the window, not just how much, are covered in depth in our context engineering guide.

This is also exactly the problem we work on at Upsolve.ai. Making an LLM reason accurately over your product's data means feeding it the right schema, metrics, and history within a finite window. Upsolve's AI analytics layer handles that context curation so your users get correct answers instead of confident guesses over a noisy dump.

Frequently Asked Questions

What is a context window in an LLM? 

A context window is the maximum number of tokens a model can process in one request: prompt, attached files, conversation history, reasoning tokens, and response combined. When it fills, older content must be dropped or summarized.

Which LLM has the largest context window? 

As of September 2026, Grok 4.20's 2M-token window is the largest in production, though GPT-5.6 (1.05M), Claude Opus 5/Sonnet 5 (1M), and Gemini 3.1 Pro (1M) lead among current flagships. Larger windows have been advertised, Meta claimed 10M tokens for Llama 4 Scout, but advertised size and effective performance are different things.

How many words is a 1 million token context window? 

Roughly 750,000 words, since one token averages about three-quarters of an English word. That's several novels, a mid-sized codebase, or hundreds of documents in a single request.

Does a bigger context window make an LLM smarter? 

No. Chroma's research across 18 leading models shows accuracy degrades as input grows, especially with irrelevant or distracting content present. A larger window increases what you can send, not what the model uses well.

Do output and reasoning tokens count against the context window? 

Yes. The window is a shared budget: max output tokens (typically 64K-128K) and, on reasoning models, thinking tokens all draw from the same limit as your input.

What happens when a conversation exceeds the context window? 

Depending on the product, the request errors out, the oldest messages are silently dropped, or the app auto-summarizes earlier turns to make room; Claude, for example, compacts long conversations automatically. Either way, the model loses direct access to the original early content, which is why long sessions "forget."

Persistent agent memory is how production systems stop long sessions from forgetting.

Sources

1. OpenAI: GPT-5.6 Sol model documentation (context window and output specs). https://developers.openai.com/api/docs/models/gpt-5.6-sol

2. OpenAI: GPT-5 model documentation. https://developers.openai.com/api/docs/models/gpt-5

3. Anthropic: Context windows, Claude Platform docs. https://platform.claude.com/docs/en/build-with-claude/context-windows

4. Anthropic: What's new in Claude Sonnet 5. https://platform.claude.com/docs/en/models/sonnet-5/whats-new-sonnet-5

5. Anthropic Help Center: Context window sizes on paid Claude plans. https://support.claude.com/en/articles/8606394-how-large-is-the-context-window-on-paid-claude-plans

6. Google DeepMind: Gemini 3.1 Pro model card. https://deepmind.google/models/model-cards/gemini-3-1-pro/

7. Google AI for Developers: Gemini API model catalog (current models, context limits, and specs). https://ai.google.dev/gemini-api/docs/models

8. Chatbase: Grok 4 family pricing and context specs. https://www.chatbase.co/blog/grok-4

9. AWS: GPT-5.6 1M-token context on Amazon Bedrock. https://aws.amazon.com/about-aws/whats-new/2026/08/gpt-sol-terra-luna-long-context-bedrock/

10. InfoWorld: OpenAI's Codex context reduction for GPT-5.6. https://www.infoworld.com/article/4198811/openais-codex-context-reduction-for-gpt-5-6-sparks-dissatisfaction-among-developers.html

11. Chroma Research: Context Rot: How Increasing Input Tokens Impacts LLM Performance. https://www.trychroma.com/research/context-rot

12. arXiv: GPT-5 vs Other LLMs in Long/Short-Context Performance (FLLM 2025). https://arxiv.org/pdf/2602.14188

13. BenchLM: Grok API pricing and context specs, synced from xAI's official docs. https://benchlm.ai/xai/api-pricing