Book 5 Needs 213,000 Tokens of Memory – Be on the Right Side of Change

If you’re looking for the best AI for writing a book series, a nicer sentence-writer isn’t what you need. You need a tool that still knows, in Book Five, which hand the scar is on.

That’s a memory problem, and memory can be measured. With OpenAI’s rule of thumb that a token is about three-quarters of a word, a 40,000-word novel is about 53,333 tokens. Before you write Book 5, Books 1 to 4 add up to 213,333 tokens. That’s more than an entire 200k-token context window, before the model writes a single new line.

So the best AI for a series isn’t simply the one with the biggest window. It’s the one that turns the earlier books into a short, reliable canon and feeds that forward. This post does the napkin math, with a Python script you can rerun on your own word counts.

The tool I’d start a series with is ImagineYourBook. It’s an AI book-writing tool that turns a prompt or your notes into a complete draft with Word and EPUB export. When a series book finishes, it compiles a story bible (characters and arcs, world rules, open threads, invented terms) and starts the next volume from that canon and the previous ending, which is exactly the approach the numbers below reward.

What “best” means for a series: memory, not prose

Most “best AI writer” lists judge one chapter. A series author gets judged on the seam between books. Readers notice when a side character’s sister turns into a cousin, when a world rule quietly changes, or when the couple fights the same fight again in Book Two.

That gives you four questions to ask any tool:

1. What does it remember from earlier books, and in what form?
2. Can you edit that memory? You decide what’s canon, not the model.
3. Does it write whole books, or three paragraphs at a time?
4. Does it export files KDP accepts (Word or EPUB) so you can edit and publish?

The first question is the one that breaks most workflows, so let’s put numbers on it.

The napkin math: a series outgrows a chat window fast

Assumptions (labeled, so you can swap your own):

• Book length: 40,000 words (a typical genre-fiction novel, and the “Large Book” size on ImagineYourBook’s pricing page).
• Tokens: 1 token is about 0.75 words, per OpenAI’s guide to tokens. It’s an estimate for English; your model’s tokenizer will differ a bit.
• Story bible: 3,000 words of notes per finished book. This is my assumption: enough for characters, arcs, world rules and open threads.

Now compare that with real context windows. Anthropic’s context-window docs list a 1M-token window for its current models, including Claude Sonnet 5.5, while older models such as Claude Sonnet 4.5 have 200k. Google’s long-context guide says 1 million tokens would look like about 8 average-length English novels, which is a good sanity check on the math above.

With a 200k window, you can’t even fit Books 1 to 3 plus the book you’re writing (that’s 213,333 tokens at Book 4). With 1M, the full text runs out at Book 19. Long romance and cozy series do get there.

The story bible line barely moves. Even at Book 10, the canon is about 36,000 tokens, about 7.5% of the full text.

Why a bigger window doesn’t solve it

A 1M window means the text fits. It doesn’t mean the model uses all of it well.

The paper Lost in the Middle (Liu et al., 2023) found that models do best when the relevant information sits at the start or end of a long input, and that performance “significantly degrades” when they must use information in the middle, “even for explicitly long-context models.” Paste Books 1 to 4 to write Book 5, and Book 2’s big reveal sits right in that middle.

Chroma’s July 2025 Context Rot report evaluated 18 models and found the same pattern in a chat-memory test. Full prompts averaged about 113,000 tokens; focused prompts with only the relevant parts averaged about 300 tokens. Across all models, performance was “significantly higher” on the focused prompts, and a gap remained even with thinking modes enabled.

That’s the whole case for a story bible. It’s the series-writer version of a focused prompt: a small, curated canon instead of four books of haystack. OpenAI’s own token guide gives the same advice for oversized inputs: “Summarize or preprocess text before sending it.”

Chapter by chapter, the paste-everything prompt compounds

It gets worse when you draft one chapter per request, which is how most people use a chatbot for a long book.

Assume 20 chapters of 2,000 words per book. If every request carries all earlier text, the prompt for the last chapter of Book 5 is about 264,000 tokens. Add up all 100 requests in a five-book series and you’ve sent 13.2 million input tokens. With a story bible plus the previous chapter instead, it’s 1.07 million, about 12 times less.

What does that cost? At Anthropic’s listed Claude Sonnet 5.5 price of $2 per million input tokens and $10 per million output tokens, the paste-everything series costs about $29.07 in API fees and the bible approach about $4.80 (both include about 267,000 output tokens for 200,000 words). Prompt caching ($0.10 per million for cache hits on that model) would shrink the paste bill further.

So here’s the honest twist: on a raw API, tokens are cheap either way. I covered that in detail in what a 50,000-word AI novel draft costs on the OpenAI and Claude APIs. The real cost of the paste approach isn’t dollars. It’s continuity errors you only catch when a reader leaves a two-star review.

The Python napkin calculator

Here’s the script behind every number in this post. Change BOOK_WORDS, CHAPTERS or BIBLE_WORDS to match your series.

BOOK_WORDS = 40_000        # ASSUMPTION: one 40k-word novel per book
WORDS_PER_TOKEN = 0.75     # OpenAI rule of thumb for English
CHAPTERS = 20              # ASSUMPTION: 20 chapters of 2,000 words
BIBLE_WORDS = 3_000        # ASSUMPTION: story-bible words per finished book
IN_PRICE, OUT_PRICE = 2.00, 10.00   # $/1M tokens, Claude Sonnet 5.5

def tok(words): return words / WORDS_PER_TOKEN
BOOK = tok(BOOK_WORDS)
def history(n): return (n - 1) * BOOK            # full text of Books 1..n-1
def bible(n):   return (n - 1) * tok(BIBLE_WORDS)

def first_overflow(window):  # first book whose history + itself no longer fits
    n = 1
    while history(n) + BOOK <= window: n += 1
    return n

def series_input(books, mode):  # total input tokens, one request per chapter
    ch, total = BOOK / CHAPTERS, 0
    for n in range(1, books + 1):
        for j in range(CHAPTERS):
            total += history(n) + j * ch if mode == "paste" else bible(n) + ch
    return total

def api_cost(books, mode):
    return series_input(books, mode) / 1e6 * IN_PRICE + books * BOOK / 1e6 * OUT_PRICE

for n in (2, 3, 4, 5, 10):
    print(f"Book {n:>2}: history {history(n):>9,.0f} | bible {bible(n):>6,.0f}")
print("200k overflows at Book", first_overflow(200_000), "| 1M at Book", first_overflow(1_000_000))
for m in ("paste", "bible"):
    print(m, f"{series_input(5, m)/1e6:.2f}M tokens, ${api_cost(5, m):.2f}")

Output:

Book  2: history    53,333 | bible  4,000
Book  3: history   106,667 | bible  8,000
Book  4: history   160,000 | bible 12,000
Book  5: history   213,333 | bible 16,000
Book 10: history   480,000 | bible 36,000
200k overflows at Book 4 | 1M at Book 19
paste 13.20M tokens, $29.07
bible 1.07M tokens, $4.80

If you’d rather build your own bible pipeline, Finxter’s LangChain Python tutorial is a good starting point for chaining “summarize the finished book” and “draft the next chapter” steps.

Where continuity pays: the Book 1 to Book 2 handoff

Why care this much? Because a series earns on read-through, and the first handoff is where it leaks.

Kindlepreneur’s read-through guide says many authors see about 50-60% from Book 1 to Book 2 in sales, and its author considers under 75% low in Kindle Unlimited for a book that has found its audience. Its example five-book series keeps 65, 50, 48 and 45 readers out of every 100 who read Book 1.

In my best AI for writing romance novels breakdown, that same curve makes each Book-1 reader worth about $3.07 in KU page reads across five books. A Book Two that “forgets” Book One cuts straight into that number. For the page-read side, see how to get more Kindle Unlimited page reads.

Three ways to give an AI series memory

What ImagineYourBook adds on top of the bible itself: its FAQ says you can start from scratch, turn any finished book into Book One, or upload your own manuscript and continue it, and that series bibles are included on every plan and use no extra credits. Credits only pay for new words: a 40,000-word novel uses 8 credits.

A 30-minute test before you commit to any tool

1. Write a one-page canon for your series: names, ages, scars, family, world rules, the secret saved for Book Three, and the things that must never happen.
2. Generate a short Book Two opening (one chapter is enough) from that canon in each tool you’re testing.
3. Plant three traps. Ask for a scene that touches a minor character, a world rule and an open thread.
4. Count the errors. Any contradiction of canon is a fail, however good the prose.
5. Check the export. Open the Word or EPUB file and confirm the chapters and headings come through cleanly for KDP.
6. Price the whole series, not one book. Multiply your words by the tool’s cost per 1,000 words.

If you publish monthly, the drafting tool is also your cadence. I ran those numbers in how often you can publish on KDP: one book a month gets you to 25 books in 25 months.

Limits of this math

• Token counts are estimates. OpenAI says 0.75 words per token is a rough guide for English; dialogue-heavy fiction and invented names can tokenize differently.
• The 3,000-word bible is my assumption. Big epic fantasy casts need more, but even 10,000 words a book stays far below the full text.
• Prices change. API and plan prices here were checked on October 23, 2026.
• No tool guarantees sales. Readers buy Book Two because Book One was good; memory just keeps you from breaking that promise.

The takeaway

The best AI for writing a book series is the one that remembers the right things, not everything. By Book 5 the full text is 213,333 tokens, bigger than a 200k window and deep in the zone where research shows models lose track of the middle. A story bible of about 16,000 tokens carries the same canon, cheaper and more reliably.

If you want that workflow without building it, try ImagineYourBook. The $0 trial gives you one complete 10,000-word book in 7 days; it needs a card, and the first $29.99 Author payment starts after 7 days unless you cancel before day 8. Write Book One, then check whether Book Two remembers it.

Sources (checked October 23, 2026): OpenAI Help: understanding and counting tokens · Anthropic: context windows · Anthropic: pricing · Google Gemini API: long context · Liu et al.: Lost in the Middle (arXiv 2307.03172) · Chroma: Context Rot (July 2025) · Kindlepreneur: calculating series read-through · KDP content guidelines · ImagineYourBook pricing and FAQ · Related on Medium: AI can draft 10,000 words in minutes; the next 60,000 are the job. Script: series_memory.py (shown above).