AI Context Window Comparison (2026): Every Major Model
Thirteen models now accept a million tokens or more. When everyone has a big window, the size of the window stops being a reason to pick one model over another.
Three other numbers decide it. The first is price: filling a 1M window costs $0.14 on DeepSeek V4 Flash and $10.00 on Claude Fable 5, 71 times more. The second is the output cap, which runs from 64K to 384K tokens. The third is effective context, the length at which answers stay good. On every model anyone has benchmarked, that length is shorter than the advertised one.
A quick definition, since the rest of this post depends on it. A model’s context length, or context window, is the most text it can handle in one request, counting both what you send and what it writes back. It’s measured in tokens. A token is about 3 to 4 characters, or three quarters of an English word. The biggest advertised windows in 2026 are Llama 4 Scout’s and Gemini 3 Pro’s, at 10 million tokens. In practice most models give reliable answers up to about 60 to 70% of their stated maximum.
Below are the numbers we’d want before choosing a model for long inputs: window size, output cap, the cost of one full window, and where quality starts to slip.
The Advertised Number Is the Wrong Number
A 1M window tells you how much the model will accept. It says nothing about how much the model can reason over, find things in, or write well from.
The RULER benchmark tests retrieval, multi-key lookup and pattern matching at growing lengths, and it has shown the same thing across several generations of models: how a model performs at the input size you actually use matters more than its maximum. The gap is biggest on the jobs people buy big windows for, like reasoning over a whole repository, long agent sessions and pulling together many documents.
Chroma tested 18 models on long inputs and all 18 got worse as the input grew. The strangest result: models did better on shuffled text than on text that read naturally. Coherent text gives the model stronger patterns to latch onto, and models lean toward whatever came last, underweighting the beginning. A model with a 1M window can start slipping at 50K tokens. The window tells you what fits. It doesn’t tell you what the model pays attention to.
Our rule of thumb is to count on 60 to 70% of the advertised window, and to expect a cliff rather than a slope. Quality tends to hold, then drop fast past some threshold. Design for that threshold.
2026 Context Window Comparison: The Full Table
Figures as of August 2026, at standard API prices.
10M Token Models
Gemini 3 Pro: 10M tokens | Input: $12/M | Output cap: 65,536 tokens | Long-context tier: 2x above 200K tokens. It holds the record for window size. What matters more in practice is the price doubling above 200K tokens. Anthropic dropped its long-context surcharge, so Google is now the only one of the three big labs that charges one. If your requests often go past 200K, that doubling will hit you long before the 10M ceiling does.
Llama 4 Scout: 10M tokens | Open weights, self-hosted | Speed: 2,600 tokens/sec, the fastest on the leaderboard. The biggest advertised window of any model, and no published benchmark shows quality holding anywhere near it. If you have the GPUs to run it yourself, the economics are attractive: you pay for hardware time instead of per token.
1M Token Models (Frontier Tier)
Claude Opus 5: 1M tokens | Input: $5/M | Output cap: 128K tokens | Quality Index: 63.1 (HLE benchmark). Anthropic has no long-context surcharge, so a 900K-token request costs the same per token as a 9K one. Two things to check. On Microsoft Foundry, Claude Opus 4.8 is capped at 200K, while the Claude API, Bedrock and Vertex AI give it the full 1M, so look at the platform you deploy on and not only the model card. And Opus 4.7 and later use a new tokenizer that turns the same text into up to 35% more tokens than older models did, so the same repository takes up more of the window and more of your budget.
Claude Fable 5: 1M tokens | Input: $10/M | Output cap: 128K tokens | AA-LCR long-context score: 77%. Back in general availability since July 1, 2026, after a short suspension over export controls. The same tokenizer note applies.
GPT-5.5 / GPT-5.6 Sol: 1M tokens | Output cap: 128K tokens (GPT-5.5). GPT-5.6 Sol tops the SWE-Bench agentic coding leaderboard at 96.2%. For coding agents, the 128K output cap is usually the real limit. An agent that can read 1M tokens but write only 128K per turn needs several round trips for a big refactor, and each trip sends the growing history again.
DeepSeek V4 Flash: 1M tokens | Input: $0.14/M (cache miss) | Output cap: 384K tokens | Open weights on Hugging Face. The cheapest full window of any 1M model, and three times the output cap of anything else. Cached input drops to $0.0028/M. If you run a lot of long requests and cost is the main concern, nothing else comes close.
DeepSeek V4 Pro: 1M tokens | Input: $0.55/M | Output cap: 384K tokens. The same output cap as Flash, with better quality. 1.6T total parameters, 49B active.
Gemini 3.1 Pro: 1M tokens | Input: $2.50/M | Output cap: 65,536 tokens | Long-context tier: 2x above 128K tokens. Handles text, images, audio and video natively. The price doubling above 128K is its main drawback for heavy long-context use.
Qwen3.5-Plus: 1M tokens | Input: $0.60/M. Alibaba’s hosted version. New Model Studio users get 1M free tokens, valid for 90 days. The open Qwen3.5 weights are also available to run yourself.
Standard Context Models (128K–200K Tokens)
DeepSeek V3: 128K tokens | Input: $0.27/M | MIT license. A cheap choice when everything fits in 128K, and open source, so you can customize it or run it on your own servers.
GLM-4.7-Flash / GLM-4.5-Flash | Free on the Z.AI API. Worth a look if you’re testing open-weight models or want experiments that cost nothing.
Output Caps: The Constraint That Binds First
Input windows have settled at around 1M. Output caps haven’t, and for most engineering work the output cap is what you hit first.
The window covers input and output together. The output cap is the most the model will write back in one request. This is where the models really differ:
384K output: DeepSeek V4 Pro and Flash, three times anything else at the frontier. If your agent writes edits across many files, or you generate long documents, this is the number to look at.
128K output: Claude Fable 5, Opus 4.8/4.7/4.6, GPT-5.5 and GPT-5.4. Anthropic has one way around it: the Batch API allows 300K output on Opus 4.6 and later and on Sonnet 4.6, with a beta header.
64–65K output: Claude Sonnet 4.6 and Gemini 3.1 Pro. For a coding agent doing a big refactor, that means more round trips and more history sent again each time, and the cost adds up.
An agent session with 50 or more tool calls can build up over 150K tokens of history, and you pay for all of it again on every call that follows. That repeated history is where long-context bills usually come from, more than any single big request.
Cost Per Full Window: The Number Vendors Don’t Lead With
Price per token hides the number that matters for long inputs: what it costs to fill the window once. On DeepSeek V4 Flash that’s $0.14. On Claude Fable 5 it’s $10.00. Same input, 71 times the price.
If you run long requests every day, such as nightly codebase analysis, batch document processing or large retrieval pipelines, that difference grows quickly. A job that costs $140 a day on DeepSeek V4 Flash costs $10,000 a day on Claude Fable 5 at the same volume.
For low-volume work where quality comes first, like legal review, compliance analysis or security audits, the premium can be worth it. For high-volume work where cost matters, it almost never is. Most teams have both kinds of work, which is why it pays to be able to send different jobs to different models without rebuilding anything.
Choosing the Right Context Window for Your Workload
Rough conversions: a token is about 4 characters, or three quarters of an English word. A line of code averages about 10 tokens, more if it’s dense or deeply indented. Here’s what common jobs need:
Codebase analysis: A 100,000-line repository fills a 1M window before you add the system prompt, the conversation or any tool output. Once you’re past about half the window you have to choose: fetch only the relevant files with agentic search, or compress the history you carry forward. Reasoning over a whole repository is exactly what 1M windows are for, but leave room for everything else that rides along.
Document processing: A 50,000-word document is roughly 65,000 to 70,000 tokens, so a 128K model handles one long document easily. Legal review and contracts with several exhibits usually land between 200K and 400K. A whole book, or many documents at once, needs 1M or more.
Agent sessions: Customer service agents usually build up 32K to 128K tokens over a session. Multi-step workflows with tool calls grow faster: 50 tool calls can add 150K tokens of history on their own. Agents that work across several connected systems often need 1M tokens of effective context, which means more than 1M advertised.
Research synthesis: One paper fits in 128K to 200K tokens. Literature reviews and comparisons across many papers benefit from 1M or more. The limit is usually how well the model finds things deep in the input, more than the raw window size.
Context Rot: Why Bigger Isn’t Always Better
Context rot is the drop in answer quality as the input gets longer, whether or not you’re near the limit. Every model tested shows it. The lesson from RULER and the benchmarks since: at 10K tokens and at 500K tokens, you’re effectively using two different models.
The best-documented version is “lost in the middle”. Models find information at the start or end of a long input more reliably than information in the middle. In a 500K-token prompt, something important near the beginning has to compete with the model’s pull toward what came last.
So order matters. Put the most important material first and last, and the supporting detail in the middle, whatever model you use.
Compression also tends to beat a bigger window in research. Summarizing earlier turns, shrinking retrieved documents before you add them, and retrieving only the relevant passages instead of loading everything often give better answers than just using more of the window.
Frequently Asked Questions
What is context length in AI?
Context length, also called the context window, is the most text an AI model can handle in one request, measured in tokens. It counts both what you send and what the model writes back. A token is roughly 3 to 4 characters, or three quarters of an English word, so a standard 250-word page is about 330 tokens. In 2026, windows range from 128K tokens on standard models to 10M tokens on Llama 4 Scout and Gemini 3 Pro.
Which AI model has the largest context window in 2026?
Llama 4 Scout and Gemini 3 Pro both advertise 10 million tokens, the largest as of August 2026. No published benchmark shows either one keeping its quality anywhere near 10M. Among frontier models with published long-context scores, Claude Opus 5, Claude Fable 5, GPT-5.5/5.6 and DeepSeek V4 all offer 1M tokens.
What happens when you exceed the context window?
Most APIs return an error. Some quietly drop the oldest content to make it fit, and providers don’t always document which they do. In practice you’ll notice problems before you reach the limit, because quality usually drops at 60 to 70% of the advertised maximum.
How many tokens is a page of text?
A standard 250-word page of English is about 330 tokens. A dense technical page with code, tables or jargon runs 400 to 500. So a 128K window holds roughly 250 to 380 pages, and a 1M window about 1,400 to 2,000. Code is denser: a 100,000-line repository can fill a 1M window before you add the system prompt or the conversation.
Is a bigger context window always better?
No. A bigger window costs more per request, adds latency, and doesn’t make the model reason better. Every model tested gets worse as the input grows. If your work fits in 128K tokens, paying for a bigger window usually buys you nothing. Ask whether your work really needs long inputs, and if it does, which model holds up at the lengths you actually use.