Claude Fable 5’s memory story is easy to oversimplify. Anthropic says the model can stay focused across millions of tokens in long-running work and improve its output with its own notes. The product page goes further, describing agents that can work for days, plan across stages, delegate to subagents, and check their own results.
Those are meaningful advances, but they do not create magical, universal recall. Reliable long-running work depends on several layers: the model’s context window, an agent’s active session, persistent files or memory stores, compaction, and an application’s authoritative records. Each layer solves a different problem.
Context is working memory, not a permanent biography
Anthropic documents a 1-million-token context window for Fable 5 and Mythos 5, with up to 128,000 output tokens per request. That capacity can hold a substantial codebase, research corpus, task history, or set of tool results. It reduces the need to discard useful evidence early in a project.
Yet context is still the material supplied to a model invocation or maintained by a supported session. It does not imply that Fable remembers an unrelated API call next week. If an application starts a new conversation without restoring relevant state, the model cannot reconstruct private facts it was never given.
Long context also has practical costs. More input increases latency and token charges, and an undifferentiated archive can make important instructions harder to find. A million-token ceiling is capacity, not a target. Good systems retrieve the relevant evidence, maintain stable instructions, and keep bulky artifacts outside the prompt until needed.
Persistent notes add a second layer
Anthropic’s launch post highlights an internal game evaluation in which Fable used file-based memory. When playing Slay the Spire, access to persistent files improved its performance substantially more than the same technique improved Opus 4.8, and Fable reached the game’s final act more often. The lesson is not about games; it is that the model appears better able to write useful notes and consult them later.
A note can preserve a plan, summarize a completed stage, list unresolved questions, or record an observation that would otherwise fall outside the active context. This is different from simply replaying the entire transcript. Notes can be compact, organized by purpose, and revised when evidence changes.
Useful project memory often separates:
- goals and acceptance criteria;
- facts with source references;
- decisions and who approved them;
- completed actions and their outputs;
- open risks and next steps;
- temporary hypotheses that are not yet trusted.
The separation matters because agents can write incorrect notes. Once a mistake is stored and repeatedly retrieved, it can become a self-reinforcing assumption. Persistent memory therefore needs provenance, timestamps, and a way to supersede stale entries.
Memory tools and compaction serve different purposes
Anthropic lists the memory tool and compaction among Fable 5’s supported platform features. A memory tool gives an agent a controlled way to store and retrieve information outside the immediate response. Compaction reduces an expanding interaction history into a smaller representation so the agent can continue working without carrying every token verbatim.
Neither mechanism is a substitute for the other. Compaction helps a session continue; it can omit detail and should not be the sole audit record. A memory store preserves selected facts; it should not become a dumping ground for every tool result. The original source files, structured logs, and generated outputs still need their own storage.
The model also uses adaptive thinking and can receive task budgets for long agent loops. These influence how it allocates effort, but they do not guarantee completion. A task can still fail because a tool is unavailable, a credential expires, an instruction is ambiguous, or the model takes a wrong turn.
What multi-day autonomy actually requires
The phrase “work for days” describes a system capability, not a single uninterrupted text generation. An agent harness must schedule turns, retain files, reconnect to tools, monitor budgets, and recover from process failures. A production implementation should create explicit checkpoints after meaningful stages.
A checkpoint should answer:
- What was the intended outcome of this stage?
- What files, records, or external systems changed?
- Which validations passed or failed?
- What remains uncertain?
- What input is required before the next stage?
This structure makes resumption safer. If the runtime restarts, a new model version is selected, or a person takes over, the project can continue from evidence rather than from a vague narrative summary.
Human approval remains important for irreversible actions. Fable’s ability to keep going is valuable for research, migrations, and large analytical projects, but autonomy should not expand permission. An agent that can work longer has more opportunity to propagate an early error or consume an unbounded budget.
Memory quality is more important than memory volume
Teams evaluating long-running memory should not ask only how many tokens a model accepts. They should measure whether it recalls the right constraints at the right time and whether its notes remain accurate after many stages.
An evaluation can plant facts with different priorities: a permanent policy, a project-specific preference, a revoked instruction, and an unverified hypothesis. Later tasks should test whether the model follows the permanent policy, retrieves the current preference, ignores the revoked instruction, and labels the hypothesis as uncertain.
Other useful measures include recovery after compaction, duplicated tool calls, stale-note rate, citation accuracy, completion after a restart, and human time required to repair the project state. Compare those outcomes with a simpler retrieval system. A sophisticated memory feature is worthwhile only when it improves delivery.
Memory records should also have a small schema. Give each entry a type, source, creation time, confidence, owner, and supersession pointer. Keep observations separate from instructions and decisions. When a note is corrected, retain the history but make the current value unambiguous. This is less glamorous than a huge context window, yet it prevents the model from treating yesterday’s tentative guess as today’s approved fact.
Costs and security boundaries
Fable 5 is priced at $10 per million input tokens and $50 per million output tokens in Anthropic’s launch materials. Prompt caching can reduce the cost of reused input, but long-running agents also incur tool charges, storage, compute, and failed attempts. An agent that writes concise, useful notes can cost less than one that repeatedly reloads a large corpus.
Persistent memory creates a security obligation. Do not store secrets merely because they may be useful later. Separate credentials from model-readable project notes, restrict file and tool permissions, and define retention rules. A private data source should not become broadly available to every future session or subagent.
Memory also needs deletion and correction. If a user revokes consent for an asset or a project changes direction, the authoritative record should mark the old state invalid and prevent it from being retrieved as a current instruction.
A persistent multi-asset media project with Medux
Consider a campaign made from several approved clips, a narration track, and a final brand sequence. Claude could plan the assembly over multiple stages while Medux performs specific media operations through a separately configured MCP connection. This is an adjacent workflow; Fable 5 is not built into Medux, and Medux does not provide Fable’s model memory.
Claude’s project notes might record the intended clip order, editorial rationale, and unresolved review comments. The authoritative operation ledger should separately store each file hash, upload status, Medux task ID, output URL, duration check, and approval. If the context is compacted or the model changes, those records remain exact.
The Claude MCP video merge tutorial demonstrates how multiple uploaded clips become an asynchronous task that is polled to completion. The guide to adding an audio track with Claude MCP shows a related two-input workflow. For a long project, each completed task should become a checkpoint rather than a detail remembered only in chat.
A sound division of responsibility is simple: Fable maintains intent, plans, and review context; structured storage maintains facts and operation state; Medux performs the approved media transformation; a human approves publication. Long-running memory becomes most useful when it coordinates those layers without pretending to replace them.