The Vibe Father
Roundup
A million tokens of context used to be a keynote flex. In mid-2026 it is nearly table stakes: eight of the models on our board ship a 1M-token window, spanning every price tier from Claude Fable 5 at $50 per million output tokens down to MiniMax M3 at $1.20. This roundup covers who has one, what a million tokens actually holds, and — the part the keynotes leave out — when it genuinely matters versus when it is an expensive way to make a model worse.
Who has a million-token window
Scores from public sources; a dash means the lab has not published that number. Live board at /benchmarks.
| Model | Context | SWE-bench | In / Out per M | Tokens/sec |
|---|---|---|---|---|
 Claude Fable 5 | 1M | 95.0 | $10 / $50 | 67 |
| Claude Opus 4.8 | 1M | 88.6 | $5 / $25 | 60 |
| Claude Sonnet 5 | 1M | 85.2 | $3 / $15 | 89 |
 Gemini 3.5 Flash | 1M | 79.3 | $1.50 / $9 | 167 |
 DeepSeek V4 Pro | 1M | 77.6 | $0.435 / $0.87 | 64 |
 Qwen3.7 Max | 1M | 77.3 | $2.50 / $7.50 | 204 |
| Gemini 3.1 Pro | 1M | 75.6 | $2 / $12 | 147 |
 MiniMax M3 | 1M | — | $0.30 / $1.20 | 95 |
The notable holdouts: Grok 4.5 ships 500k, GPT-5.3 Codex 400k, Kimi K2.7 Code 262k, and Haiku 4.5 stays at 200k. None of those are small — 200k was the frontier not long ago — but the 1M club now spans three labs' flagships and the two cheapest serious models in existence, which tells you how fast the capability commoditized.
What a million tokens actually holds
Rule of thumb: a token is roughly three to four characters of code, so 1M tokens is ballpark 3–4MB of plain text. That is a genuinely large repository's worth of source — not a monorepo, but comfortably an entire mid-sized production codebase: every file, every test, every config, in one prompt. It is also, for scale, several long novels, or months of accumulated conversation. When Fable 5 plans a refactor with the whole repo in view, that is not marketing language; the whole repo literally fits.
The price of that view is the price of the tokens. Filling a 1M window on Fable 5 costs about $10 per read; on DeepSeek V4 Pro, about 44 cents. If you are going to make repo-stuffing a habit, the bottom half of the table is where the habit is affordable.
The honest part: the limit is not the useful limit
Here is what the spec sheet does not say. Effective use of a context window degrades well before the advertised limit. The pattern — often called "lost in the middle" — is well documented: models attend most reliably to the beginning and end of a long prompt, and recall of details buried in the middle drops as the window fills. A model that is razor-sharp at 50k tokens can get vague, repetitive, or subtly wrong about mid-context facts at 800k, while still technically "supporting" the input. The benchmark number that got you to buy the model was almost certainly not measured with the window full.
The practical consequence: retrieval plus focused context beats stuffing, nearly always. Handing a model the twelve files relevant to a task — found by search, a code index, or a scout agent — produces better and cheaper results than handing it four hundred files and hoping attention finds the right ones. We treat the 1M window as headroom for the cases that genuinely need breadth, not as an invitation to stop curating.
One more distinction worth being precise about: long context is not long memory. The window is per-conversation; when the session ends or compacts, it is gone. A 1M window does not remember last Tuesday. Persistence across sessions is a different problem with different tools — we cover it in the session limit survival guide.
When 1M genuinely matters
Three cases earn it. Whole-repo reasoning: architecture reviews, cross-cutting refactors, "where would this change break things" — questions whose answer lives in the relationships between many files at once, where curation would amputate the signal. Long agentic sessions: an agent that has been working for hours accumulates its own history, tool outputs, and diffs, and a big window delays the day compaction starts eating its memory. And large single artifacts — a giant log file, a data dump, a legacy module nobody dares split — that simply do not fit in 200k.
For everything else, the window you need is the size of the problem, not the size of the spec sheet. A tight prompt into Fable 5 beats a stuffed one into anything.
Practical habits for big windows
A few patterns that make the difference between a 1M window helping and hurting. Put the load-bearing material at the edges: instructions and the immediate task at the end of the prompt, the most important reference files at the start, and the bulk in between — that is where mid-context degradation bites least. Prefer many focused calls over one stuffed call: three passes with 80k of curated context each will usually beat one pass with 900k, and on most of the models above it will cost less too. And when you do go wide, make the model cite its way through the material — asking it to name the files and lines it is relying on surfaces mid-context blindness immediately, while a fluent unanchored summary hides it.
For agent sessions specifically, treat the window as a budget you spend down, not a bucket you fill. Tool outputs, diffs, and file reads accumulate fast, and an agent at 90% context behaves measurably worse than the same agent at 30% — sluggish, forgetful of early instructions, prone to re-reading things it already knows. Summarize and restart before the wall, not at it.
Bottom line
Eight models, three labs, prices from 30 cents to 10 dollars per million input: the 1M window is no longer a differentiator, it is a checkbox. What differentiates is what the model does with token 700,001 — and that is exactly what the spec sheet will not tell you. Current windows, prices, and scores, refreshed nightly, at /benchmarks.