Can the AI read your whole serial at once? Do the math first

The AI forgetting chapter 3 by chapter 40 isn't a memory problem — it's a window problem. A 500k-word serial runs roughly 625k to 830k tokens; 2026 flagship windows reach 1M, so it technically fits. But fitting is not remembering: mid-context retrieval dips are documented in research and in vendors' own evals, and our own control experiment shows material being in the window doesn't mean it gets used. The reader's version, with arithmetic.

An immensely long manuscript scroll passing beneath a small reading window; only the lines inside the window glow warm cinnabar while the rest of the scroll fades to pale grey

You hand the AI a 500,000-word serial, ask it to continue from chapter 200, and it resurrects a character who died in chapter 3. The instinctive diagnosis is “bad memory.” The word is wrong. A language model has no memory organ — it has a window: the total text it can see inside one request. How big that window is, and how big your serial is, are both numbers you can actually compute. So compute them first, then talk about forgetting.

How many tokens is a chapter, anyway?

Models don’t count words; they count tokens. Google’s own docs put the English ratio at roughly 100 tokens per 60-80 words, so a 3,000-word chapter lands between about 3,800 and 5,000 tokens, and a 500k-word serial runs somewhere from 625,000 to 830,000. We also checked the ratio empirically on the other side of the language fence — three Chinese novels through OpenAI’s public o200k tokenizer on 2026-07-18: 3,000 characters of prose came out at 2,149, 2,524 and 2,816 tokens depending on style, the ornate historical register costing the most. Whatever you read, the ballpark holds: a chapter is a few thousand tokens; a long serial is most of a million.

Do today’s windows fit an entire serial?

They do — and that sentence only became true recently. Flagship specs, checked against official docs on 2026-07-18:

ModelContext windowNote
DeepSeek V4 (flash / pro)1M tokensThe launch note calls 1M the default across all official services
Claude (Opus 4.8 / Sonnet 5)1M tokensHaiku 4.5 and older Sonnets stay at 200k
Gemini 3 family1M tokens64k output cap
GPT-5.6 (Sol / Terra / Luna)1.05M tokens128k output cap

Sources: DeepSeek’s model page, Anthropic’s context-window docs, the Gemini 3 guide, and OpenAI’s GPT-5.6 launch page. A 500k-word serial takes up 60-80% of a 1M window — it fits, with room to breathe. Three years ago the mainstream window was 128k tokens and the same serial didn’t fit one-fifth of the way in. One boundary worth knowing: on the models still carrying 200k windows, that same serial overflows by a factor of three or four, so switching model tiers can silently change the AI’s view from “the whole book” to “the last third, beginning amputated.” Not a mood swing — a spec difference. Overall, though, the answer to “can I feed it the whole thing” flipped from no to yes, and the real question moved: should you?

Two fine-print items from the same spec sheets. Output is capped well below input — 64k tokens per reply on Gemini, 128k on Claude and GPT-5.6, 384k even on DeepSeek’s generous end — so “sees a million” never means “writes a million”; the window is a reading budget, not a writing one. And input this size is billed per token, every request, which the arithmetic below will make uncomfortably concrete.

It fits. Why does it still forget?

Because “the AI forgot chapter 3 by chapter 40” describes three different mechanisms wearing one symptom, and only the first one is about capacity. On smaller windows, chapter 3 was literally amputated — never sent. On a 1M window that actually received all forty chapters, two subtler things still happen. Three layers, each harder to dodge than the last.

Layer one: the middle goes blurry. The research name is lost in the middle — a 2024 TACL study found models score best when the relevant information sits at the beginning or end of a long context, and significantly worse when it’s buried in the middle, explicitly long-context models included. Vendor numbers agree: on the GPT-5.6 launch page, OpenAI’s own long-context eval reports 73.8% for retrieving 8 planted items at 512K-1M depth. That is the window’s seller grading its own product. Chapter 3 of your serial lives precisely in that blurry middle.

Layer two: being in the window is not being used. In the single-shot control of our style benchmark, we crammed up to 200k tokens of original prose into context with no style instruction — and the model still wrote similes at ten times the original author’s density, in its own default voice. It “saw” the whole book. It imitated itself. Seeing and using are separated by a layer that raw volume does not cross.

Layer three: zero persistence between requests. The window is per-request — what the model saw this time leaves no trace, so next time you must re-send everything. Re-sending a whole serial means every continuation pays for 700,000-odd tokens, of which well over 99% have nothing to do with the current scene. At GPT-5.6 Terra’s list rate of $2.50 per million input tokens, that is roughly $1.75 of input per press of the continue button. An evening of reading with twenty continuations re-buys the entire serial twenty times.

So does a bigger window equal better memory?

No, and the two words deserve to be pried apart. A window is eyesight: how much fits in one glance. Memory is persistence plus retrieval: still there next time, and actually consulted. The million-token windows solved “doesn’t fit.” They did not solve “fits but gets skimmed,” and they did not touch “gone by the next request.” Tenfold windows were a hardware and algorithms victory; retrieval still depends on how you feed. For the roleplay version of this problem — companions forgetting mid-campaign — the architecture is the same and written up separately; this page is the long-fiction case.

What is the right way to feed 500k words of canon?

Split it, and serve it on demand — in two tiers. Facts that must be present every single turn go in the always-on tier: who the protagonist is, how the magic system works. Those live in the character card, re-sent in full with every request, immune to getting pushed out of the window. Everything voluminous but situational becomes lorebook entries — one fact per entry, a few trigger keywords each. When the current passage mentions the Northern March, the Northern March entry enters the request; every faction and subplot not on stage waits outside, costing zero tokens. The pattern is called structured feeding, and the world-organizer page shows its full shape.

One field-tested rule for writing those entries: 150 words of telegraphic facts beat 800 words of lovely prose. The lorebook autopsy post documents an 800-word heirloom-sword entry that ate a third of the injection budget by itself, starved three concise entries out of the prompt, and still failed to land its own three key facts. Compressed to telegraph style, same model, same twenty rounds of questioning — visibly better recall.

One caveat in the other direction, for honesty’s sake: structured feeding is only as good as its entries. A lorebook keyed to names nobody uses in the actual chat will inject nothing and fail silently — which is a different disease, with its own autopsy post. The window arithmetic on this page tells you why cramming loses; it does not excuse lazy entries.

One last number of our own. The continuation experiments this site keeps citing — nine models, two genres, 360 rounds total — ran inside a fixed window of 16k tokens: the current scene, the triggered entries, the recent prose. Enough. Across 360 rounds, not one ever needed the millionth token.

FAQ

Can AI read my whole novel at once?

Technically, often yes now: a 500k-word serial runs roughly 625k to 830k tokens by Google's published ratio, and the 2026 flagship models carry 1M-token windows. Practically it's a poor default: retrieval measurably dips for material buried mid-context, our own control test showed a model ignoring 200k tokens of crammed original prose while writing in its own habits, and since models keep nothing between requests, you'd re-send the entire book for every single continuation.

Why does the AI forget chapter 3 by chapter 40?

The model has no memory organ — only a window of text it sees per request. Nothing carries over between requests unless it is re-sent. If the story outgrows the window, the oldest chapters get pushed out first; and even when everything fits, information buried in the middle of a long context is where models score worst — the documented "lost in the middle" pattern. Chapter 3 sits exactly there.

Do bigger context windows fix AI memory?

No. A window is per-request eyesight: how much it can see at once. Memory is persistence plus retrieval: whether it's still there next time, and whether it actually gets used. The 1M windows solved "doesn't fit"; they didn't solve "fits but gets skimmed" — OpenAI's own long-context eval for GPT-5.6 reports 73.8% on retrieving 8 planted items at 512K-1M depth — and they didn't touch cross-request persistence, which remains zero.

How many tokens is a typical chapter?

By Google's published rule of thumb, 100 tokens is about 60-80 English words, so a 3,000-word chapter lands between roughly 3,800 and 5,000 tokens. We also ran three Chinese novels through OpenAI's public o200k tokenizer (2026-07-18): 3,000 characters of prose came out between 2,100 and 2,800 tokens, with the ornate historical style costing the most. Ballpark either way: a chapter is a few thousand tokens.

Questions or ideas? Join our Discord →

Context Windows, Explained for Readers: How Much of a 500k-Word Serial the AI Can Actually See · Foreverse · Xinmeng