Context Windows Explained: What 1M Tokens Get You (2026)

TL;DR: As of October 2026, every major coding model — Claude Sonnet 5.5, GPT-6.1 Sol, Gemini 3.8 Flash, Gemini 4 Argon, DeepSeek V4.1 Flash, Meta Muse Wonder, Kimi K3 — ships a ~1M-token context window. But the price of filling that window ranges from $0.15 (DeepSeek, off-peak) to $20 (GPT-6 Astra), and OpenAI doubles the entire request's rate once you pass 272K input tokens. A 1M window fits roughly 750,000 words or ~4 MB of source code — and you only need it when your task genuinely can't be split up.

A year ago, a 128K-token context window was the headline spec. Today it is the table stake: every frontier model released in the last two months ships roughly one million tokens of context. The marketing all says the same thing — "paste your whole repo, your whole document set, your whole conversation."

What the marketing does not say: those million tokens are not priced equally, not even close. The cheapest full window costs $0.15; the most expensive costs $20 — a 130× spread. One provider doubles your rate partway through the window. Another bills your thinking out of the same million tokens your input and output share. And a bigger window does not mean the model remembers all of it equally well.

This post is the practical guide: what a context window actually is, what 1M tokens fits in real terms, what each current model charges for its window, and a decision rule for when you actually need it.

What a context window actually is#

The context window is a single shared budget of tokens per request. Almost everything you send and get back draws from it:

• System prompt and instructions
• Tool definitions — every function schema you hand the model (see how the tool-call loop works)
• Conversation history — every previous turn, resent in full each time
• Retrieved content — files, docs, search results you inject
• Reasoning/thinking tokens — the model's internal chain of thought
• Output — the answer itself, plus a reserved ceiling (the "max output" spec)

This is why "1M context" is not "1M input tokens plus output on top." On most models the max output is a separate cap inside the window (e.g. 128K output within a 1,050,000-token window on GPT-6.1 Sol). Gemini 4 Argon goes further: its 1,048,576 tokens are one unified pool shared by input, thinking, and output — a 900K-token prompt leaves almost no room for the answer.

Two conversions to keep in your head:

• 1M tokens ≈ 750,000 English words (the ~0.75 words-per-token rule of thumb) — roughly 1,500 book pages at 500 words a page.
• 1M tokens ≈ 4 MB of source code (~4 characters per token on average) — on the order of 100,000 lines of typical code. Illustrative, not exact: dense minified code packs tighter, heavily commented code looser.

The 2026 landscape: everyone is at 1M#

Context windows and max outputs for current coding models. Specs verified against provider docs and model cards, 20 October 2026.

The table looks like parity. The price list says otherwise.

The catch: a 1M window is not a 1M price#

Three pricing traps hide inside those identical-looking windows.

1. OpenAI's long-context multiplier. On GPT-6.1 Sol, GPT-6 Luna and GPT-6 Astra, prompts with more than 272,000 input tokens are billed at 2× the input and cache rates and 1.5× the output rate — for the entire request, not just the tokens past the threshold. Since the window is 1,050,000 tokens, the advertised $2/1M price only applies to the first 26% of the window. Fill the whole thing and you are paying $4/1M input — double Claude Sonnet 5.5's flat $2/1M, despite the identical headline price.

2. Tiered and time-of-day pricing. Claude Haiku 5.5 costs $0.10/1M input under 100K tokens and $0.50/1M above it — five times more once your context crosses six figures. DeepSeek V4.1 Flash 1017 is $0.15/$0.60 off-peak but doubles to $0.30/$1.20 during weekday peak hours (01:00–04:00 and 06:00–10:00 UTC — that's 07:00–10:00 and 12:00–16:00 in Dhaka). A long overnight batch job that drifts into the morning peak quietly doubles its own bill.

3. Intro prices with expiry dates. Gemini 4 Argon's $2/$10 rate runs only through 30 November 2026, then doubles to $4/$20 — the price of the window doubles with it. Gemini 3.8 Flash's $0.75/$3.75 intro rate doubles on 1 January 2027. If you are sizing a long-context workload on either, budget the post-deadline price, not the launch price.

Claude Sonnet 5.5 is the counterexample: 1M tokens at one flat rate, no multiplier, no tier, no expiry. Boring — and the easiest window to budget.

Worked example: what filling the whole window costs#

One request, 1,000,000 fresh input tokens, no cache. List prices checked 20 October 2026; BDT at ৳125/$1 (the conversion rate tokens.bd's own receipts use).

Three things jump out. First, the spread: Astra's full window costs over 130× DeepSeek's off-peak window ($20.00 vs $0.15). Second, the headline-price illusion: GPT-6.1 Sol and Sonnet 5.5 both advertise $2/1M input, but a full window on Sol costs twice Sonnet's because of the 272K multiplier. Third, the cheap tier is genuinely cheap: a full 1M-token window on GPT-6 Luna costs $0.20 — less than a tenth of Sonnet's — which is why long-context batch work (classification, extraction, evals) keeps migrating downward.

Through tokens.bd's catalog the same windows bill at the gateway's per-model rates — e.g. Sonnet 5.5 at $2.20/$11.00 (৳275/৳1,375) per 1M in/out and Haiku 5.5 at $0.12/$0.60 (Claude prices verified live 19 October 2026; full live pricing at /models).

Now the realistic version: nobody sends a million fresh tokens every turn. A 40-turn coding-agent session that accumulates a 600K-token context (system prompt + history + retrieved files), all fresh input:

Same workload, same token count — Sol costs exactly double Sonnet here, purely from the multiplier. This is the number that should drive your model choice for long agent sessions, not the headline $2/1M both advertise.

What actually fills a 1M-token context#

A long agent run does not fill its window with one giant document. It fills it with accumulation. Here is an illustrative breakdown of a heavy session — system prompt, tool definitions, conversation history, retrieved files, thinking, and the output reserve:

Conversation history is the silent killer: every turn resends every previous turn. That is also why it is the first thing to compress.

When you actually need 1M tokens#

A decision rule, in order of how often each case is real:

1. Whole-repo agents — yes, sometimes. If your agent edits across dozens of files and the repo is under ~4 MB of source, one 1M window genuinely holds it. This is the flagship use case and it is real.
2. Long multi-document analysis — yes. Contracts, research sets, log bundles: when the task is "find the pattern across all of these," splitting the input means the model never sees the pattern. One window wins.
3. Long conversations — usually no. Chat history past ~50K tokens is mostly dead weight. Summarize (compact) the old turns instead of resending them; you keep the decisions and drop the prose.
4. RAG workloads — measure first. Retrieval (top-K chunks) exists precisely to avoid dumping everything into context. A 1M window tempts you to skip retrieval engineering — and pay 10× per query for the privilege. Benchmark RAG against full-context on your data before choosing.
5. Single big documents — rarely. A 200-page PDF is ~150K tokens. You need 128K–256K of headroom, not a million.

The honest default: start at the smallest window that fits the task, and only move up when you can point to the failure the small window caused. A bigger window is headroom, not quality.

The retrieval tax: bigger window, weaker memory#

One more thing the spec sheets omit: models do not recall all million tokens equally. Long-context evaluations keep finding the same pattern — recall is strongest at the start and end of the context and weakest in the middle. The fact you need is disproportionately likely to be exactly where the model looks least carefully.

Practical consequences:

• Put the critical instruction last, not buried in a 20K system prompt. The most recent tokens get the most attention.
• Repeat the key constraint near the question, not just in the setup message from 30 turns ago.
• Don't use the window as a database. If you need reliable lookup over 800K tokens of logs, retrieve-then-read beats dump-everything on both accuracy and cost.
• Test with your own needles. Drop a known fact into your real context size and ask for it back. If your model can't find it at 600K tokens, the 1M spec is decoration.

Four ways to spend less on long context#

1. Cache the stable prefix. System prompts, tool definitions, and retrieved files barely change between turns — prompt caching turns re-reads into cents. The economics differ per provider (cache-read rates and the 272K multiplier interact), and the full comparison is in our prompt caching guide across Anthropic, OpenAI and Bedrock. On a 600K-token context with 90% cache hits, Sonnet 5.5 drops from $1.20 to about $0.23 per turn (0.54M × $0.20 + 0.06M × $2.00); GPT-6.1 Sol drops from $2.40 to about $0.35 (0.54M × $0.20 + 0.06M × $4.00 — the multiplier applies to cache reads too).
2. Compact history aggressively. Summarize every N turns and keep only the summary plus recent turns. This is the single highest-ROI change for agent sessions: history is usually the largest slice of the window (see the anatomy chart above).
3. Match the model to the context size. If your workload lives under 100K tokens, Haiku 5.5's $0.10/1M tier is the cheapest window in the Claude family. If it lives at 600K+, Sonnet 5.5's flat rate beats Sol's multiplied rate at the same headline price. For background batch work, Luna or DeepSeek off-peak are 10–130× cheaper than the frontier tier.
4. Watch the clock on time-of-day pricing. DeepSeek's peak hours are 07:00–10:00 and 12:00–16:00 Dhaka time on weekdays — exactly when you're most likely to run a heavy session. Schedule 1M-token batch jobs off-peak and the window costs half.

For the full anatomy of how input, output, cache and reasoning tokens each hit your bill, see how your LLM API bill really works.

FAQ#

Does a bigger context window make the model smarter? No — it gives the model more to read, not more ability to reason. A bigger window helps tasks that genuinely need broad context (whole-repo edits, multi-document synthesis). For everything else, the extra tokens are extra cost with no quality gain, and recall in the middle of very long contexts is measurably weaker.

What's the difference between context window and max output? The context window is the total budget per request; max output is the cap on the model's reply within that budget. GPT-6.1 Sol's 1,050,000-token window allows at most 128,000 output tokens per request. Gemini 4 Argon is unusual: input, thinking, and output all share one 1,048,576-token pool, so a huge prompt directly shrinks the room left for the answer.

Why does the same 1M window cost $0.15 on one model and $20 on another? Because you're paying for the model's capability per token, not for the window size. The window is just the ceiling; the per-token price reflects the model's size and quality tier. DeepSeek V4.1 Flash is a small efficient model ($0.15/1M off-peak); GPT-6 Astra is a frontier model ($10/1M, doubled to $20 past 272K tokens by OpenAI's long-context multiplier).

Do I pay for the whole window or just what I use? Just what you use — every provider bills per token actually processed. The window is a limit, not a reservation. But note the trap: OpenAI's 272K multiplier reprices the entire request once you cross it, so token 272,001 changes the price of the 272,000 tokens before it.

When do Gemini 4 Argon's and Gemini 3.8 Flash's prices change? Argon's intro rate ($2/$10 per 1M in/out) runs through 30 November 2026, then doubles to $4/$20. Gemini 3.8 Flash's intro rate ($0.75/$3.75) runs through 31 December 2026, then doubles on 1 January 2027. Both dates verified 20 October 2026.

Sources#

Model specs and prices verified 20 October 2026:

• Claude Sonnet 5.5 — 1M context, $2/$10, no long-context tier: https://codersera.com/blog/claude-sonnet-5-5-complete-guide-2026/
• Claude Haiku 5.5 — 1M context, tiered pricing ($0.10/$0.50 under 100K tokens, $0.50/$2.50 above): https://developer.puter.com/ai/anthropic/claude-sonnet-5-5/
• GPT-6.1 Sol — 1,050,000 context, $2/$10, 2× input / 1.5× output past 272K input tokens: https://www.sitepoint.com/gpt-6-1-sol-developers-pricing-quickstart/
• GPT-6 Luna — 1,050,000 context, $0.10/$0.50, same 272K multiplier: https://www.worthview.com/openai-introduces-gpt-6-sol-and-luna-features-pricing-and-key-differences/
• GPT-6 Astra — 1,050,000 context, $10/$50: https://openrouter.ai/compare/google/gemini-3.8-flash/openai/gpt-6-astra
• Gemini 4 Argon — 1,048,576 unified context window, $2/$10 intro through 30 Nov 2026: https://theairankings.com/google/gemini-4-argon/ and https://www.lindy.ai/blog/gemini-4-argon-vs-gpt-6-astra
• Gemini 3.8 Flash — 1,048,576 context, $0.75/$3.75 intro, doubles 1 Jan 2027: https://www.alphaone-ai.com/blog/google-launches-gemini-3-8-flash.html
• DeepSeek V4.1 Flash 1017 — 1M context, $0.15/$0.60 off-peak, peak hours double: https://artificialwatch.com/wire/deepseek-v4-1-flash-1017-update
• Meta Muse Wonder 1.0 — 1,048,576 context, $4/$20: https://dev.to/agent-one/meta-muse-wonder-benchmarks-pricing-api-and-how-to-use-it-4jhh
• Kimi K3 — 1,048,576 context, $3/$15: https://routerplex.com/blog/kimi-k3-api-pricing-setup
• tokens.bd model catalog and BDT pricing: https://tokens.bd/models