RAG & LLM Engineering · BraivIQ AI Engineering Playbook
The 1M Token Context Window In Claude Fable 5.2: When To Use It And When Retrieval Still Wins
A 1M token context window lets an agent read a full policy set, its procedures and a year of minutes in one request. Anthropic launched Claude Fable 5.2 on 9 November 2026 with a 1M token context window, 128k max output tokens and always-on adaptive thinking, priced at $8 per million input tokens and $40 per million output. Long context changes what retrieval is for, but it does not remove the need for budgets, citations or a person checking the result. This deep dive covers the numbers, a tested budget planner and what breaks.
Published · Updated · 8 min read · By BraivIQ Engineering
Key takeaways
- Claude Fable 5.2 (claude-fable-5-2) launched on 9 November 2026 with a 1M token context window, 128k max output tokens and always-on adaptive thinking.
- It costs $8 per million input tokens and $40 per million output tokens, down from $10 and $50 for Claude Fable 5.1, according to the release notes.
- Claude Mythos 5.2 has the same capabilities but is only available to organisations verified through Anthropic programmes such as the Cyber Verification Program.
- Anthropic raised the maximum request size for the Messages API and Token Counting API from 32 MB to 128 MB on 28 October 2026.
- Use long context for the core documents a decision depends on and retrieval for large archives, and make the agent cite what it used.
1M - Token context window for claude-fable-5-2 (Claude API release notes, 9 November 2026) · 128k - Maximum output tokens for the same model · 128 MB - Maximum request size for the Messages and Token Counting APIs, up from 32 MB (28 October 2026)
The 1M token context window is the amount of text a model can take in one request, enough for thousands of pages. On 9 November 2026 Anthropic launched Claude Fable 5.2 with that window, and it is the most discussed model change of the month. For teams building agents in financial firms, the question is practical: which documents should go in whole, which should be retrieved, and how do you keep cost and review under control?
What did Anthropic release on 9 November?
The Claude API release notes of 9 November 2026 announce Claude Fable 5.2 (claude-fable-5-2), built for demanding reasoning and long-horizon agentic work. Claude Mythos 5.2 (claude-mythos-5-2) has the same capabilities but is offered only to organisations verified through Anthropic's verification programmes, such as the Cyber Verification Program.
Both models have a 1M token context window, 128k max output tokens and always-on adaptive thinking. They cost $8 per million input tokens and $40 per million output tokens. The notes give Claude Fable 5.1 and Claude Mythos 5.1 at $10 and $50 for comparison.
Claude Fable 5.2 is available on the Claude API, Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud in both Anthropic-managed and Google-managed forms, and Claude in Microsoft Foundry. The Python SDK added the model IDs in version 2.7.0, released the same day.
Two earlier changes support long requests. On 28 October 2026 the maximum request size for the Messages API and the Token Counting API went from 32 MB to 128 MB on the first-party Claude API. On 2 November 2026 message threads entered beta, keeping a conversation on the server so later requests send only new messages. Our playbook on LLM conversation state and message threads covers threads in detail.
When does a 1M token context window beat retrieval?
Long context wins when the answer depends on how documents relate to each other. Comparing this year's policy with last year's, checking procedures against the policy they implement, or reading a full set of board minutes for every mention of a risk are all cross-document tasks. Retrieval breaks those into chunks and can miss the link.
Retrieval still wins for large archives where only a few passages matter, such as years of email or every client file. It is cheaper per question, faster, and the passages it returns make citations easy. Most real tasks use both: core documents whole, archives retrieved.
| Task | Better fit | Why |
|---|---|---|
| Compare two versions of a policy | Long context | The changes only make sense side by side |
| Check procedures against policy | Long context | Every procedure needs the whole policy in view |
| Find mentions of a supplier in five years of email | Retrieval | A handful of passages in millions of tokens |
| Answer a client question from the knowledge base | Retrieval | Short, cited answers at low cost |
| Draft a board paper from minutes and MI | Both | Minutes whole, supporting data retrieved |
How do you budget a long-context request?
Plan the budget before the call. Reserve room for the system prompt, the output you expect and a safety margin, then fill the rest by priority. Confirm the count with the Token Counting API rather than trusting a characters-per-token guess, which varies by language and format.
context_budget.py"""Plan what goes into one long-context request and what goes to retrieval.
Python 3.14, standard library only. Limits and prices are from the Claude API
release notes of 9 November 2026 for claude-fable-5-2: 1M token context window,
128k max output tokens, $8 per million input tokens and $40 per million output."""
CONTEXT, MAX_OUTPUT = 1_000_000, 128_000
IN_PER_M, OUT_PER_M = 8.0, 40.0
CHARS_PER_TOKEN = 3.5 # planning guess only, confirm with the Token Counting API
DOCS = [ # sample document set for a policy review: name, characters, priority
("policy-current.md", 180_000, 1), ("policy-2025.md", 175_000, 1),
("procedures.md", 420_000, 2), ("board-minutes-2026.md", 900_000, 3),
("email-archive.mbox", 2_600_000, 4), ("glossary.md", 30_000, 2),
]
def tokens(chars: int) -> int:
return int(chars / CHARS_PER_TOKEN)
def plan(docs, system_tokens=4_000, output_tokens=16_000, margin=0.10):
budget = int(CONTEXT * (1 - margin)) - system_tokens - min(output_tokens, MAX_OUTPUT)
whole, retrieve, used = [], [], 0
for name, chars, prio in sorted(docs, key=lambda d: (d[2], d[1])):
t = tokens(chars)
if used + t <= budget and prio <= 3:
whole.append((name, t))
used += t
else:
retrieve.append((name, t))
cost = (used + system_tokens) / 1e6 * IN_PER_M + output_tokens / 1e6 * OUT_PER_M
return whole, retrieve, used, budget, cost
if __name__ == "__main__":
whole, retrieve, used, budget, cost = plan(DOCS)
print(f"input budget {budget:,} tokens, planned {used:,}")
for name, t in whole:
print(f" in context {name:24} {t:>9,}")
for name, t in retrieve:
print(f" retrieval {name:24} {t:>9,}")
print(f"estimated cost per request ${cost:.2f}")Python 3.14, standard library only. Limits and prices from the Claude API release notes of 9 November 2026. With a sample document set it keeps the policies, procedures and minutes in context, sends a 740,000-token email archive to retrieval and estimates $4.57 per request.
The estimate is the useful part. At $8 per million input tokens, a request that fills half the window costs about four dollars before any output. An agent that sends that request for every question will cost far more than a team expects. Message threads can reduce what you resend on later turns, and caching the stable documents is worth testing.
How do you keep long-context answers checkable?
Ask for citations by document and section in every answer, and check them in code before a person sees the draft. A citation to a section that does not exist, or a quote that does not appear in the source, sends the draft back. This is cheap to build and catches the most damaging errors.
The reviewer then approves or rejects the draft with the citations alongside. Log the document versions, token counts, cost and reviewer for each run. Our human-in-the-loop explainer describes how that sign-off works for non-technical teams.
What breaks in production?
- **Cost creep.** Full-window requests on every question add up fast. Track cost per task, not per call.
- **Latency.** Larger inputs take longer to process. Agree a latency budget with the team that waits for the answer.
- **Stale documents.** A policy loaded into a long-running thread may be out of date by the next turn. Check versions on every request.
- **Buried facts.** Models can still miss a detail in a very long input. Test with known facts placed at different depths in your own documents.
- **Output limits.** 128k output tokens is a ceiling, not a target. Ask for structured, short answers and let the reviewer expand.
- **Data rules.** Putting every document in one request sends every document to the provider. Check your data classification before you load an archive.
What are the trade-offs and alternatives?
The main alternative is a well-built retrieval pipeline with re-ranking, which stays cheaper and is easier to cite. A middle path is retrieval at document level, choosing whole documents rather than chunks, then sending those in full. That keeps cross-document reasoning without paying for the archive.
Smaller models with shorter windows remain the better choice for high-volume classification. Keep the 1M window for the tasks that need it. Our AI developers London team usually starts clients on document-level retrieval and adds full long context only where evaluation shows a gain.
Where should a team start?
Pick one cross-document task, such as checking procedures against a policy, and run it three ways: chunk retrieval, document-level retrieval and full long context. Compare accuracy, cost and time on your own documents. Agentic AI London clients often begin with MI and board packs, and a 14-day Proof Run can run that comparison on your data. This guide is engineering guidance, not legal or regulatory advice.
Frequently asked questions
What is the context window of Claude Fable 5.2?
1M tokens, with up to 128k output tokens, according to the Claude API release notes of 9 November 2026.
How much does Claude Fable 5.2 cost?
$8 per million input tokens and $40 per million output tokens, compared with $10 and $50 for Claude Fable 5.1.
Does a 1M token context window replace retrieval?
No. It suits tasks that need several documents side by side. Retrieval stays cheaper and easier to cite for large archives where only a few passages matter.
What is Claude Mythos 5.2?
A model with the same capabilities as Claude Fable 5.2, available only to organisations verified through Anthropic's verification programmes, such as the Cyber Verification Program.
References
- Anthropic, "Claude API release notes", 28 October to 9 November 2026. https://docs.claude.com/en/release-notes/api
- Anthropic on GitHub, "anthropic-sdk-python v2.7.0 release notes", 9 November 2026. https://github.com/anthropics/anthropic-sdk-python/releases/tag/v2.7.0