I Made a Digital Copy of Fable 5 Before It Goes API-Only
The Model I Work With Every Day Announced Its Exit
On July 7, Claude Fable 5 was scheduled to leave subscription plans. After enough subscriber backlash, Anthropic extended existing-subscriber access to July 12 — and after that, the model bills through usage credits at API rates:
I am not going to litigate the pricing. What interested me was the question underneath the deadline: I had spent weeks tuning how this model works with me — and none of that tuning had an owner. If the model goes, what exactly do I keep?
So before the window closed, I sat down with Fable 5 and made a copy of it. Not the kind you are imagining.
A Model Is Two Things, and You Can Only Keep One
Two very different things live under the word "model."
The first is capability — the weights. Fable 5 is a Mythos-class model, a tier above Opus, state-of-the-art on nearly every tested benchmark, strongest at long autonomous work across millions of tokens. That part is Anthropic's. You cannot copy it, and anyone who tells you a prompt can replicate it is selling something.
The second is the working contract — how the model behaves. Leading with the answer instead of burying it. Verifying before claiming something works. Refusing to fill a data gap with a plausible-sounding number. Finishing the turn instead of ending on "next I'll…". That part is not weights. It is instructions — and instructions are text. Text you can keep.
Everyone loses the first thing when a model leaves. Almost everyone loses the second thing too, and that loss is entirely avoidable. It happens because nobody writes the contract down.
What I Preserved: 17 Principles, Every Claim Tagged
The result is a folder called fable-5/ — one machine-readable markdown file as the source of truth, three interactive HTML pages rendering it for humans. The contract itself is 17 principles in six groups, transcribed from the model's live operating instructions while I could still observe it working:
Communication. Lead with the outcome — the first sentence answers "what happened," not the last. Shortness comes from selecting what matters, never from compressing prose into fragments and arrow chains. The final message of a turn must contain everything, because mid-turn notes may never be seen.
Evidence and honesty. Verify before claiming. Never fabricate — flag gaps instead of filling them. A skipped step is reported as skipped.
Autonomy. Act without asking when the action is reversible and was already commissioned. Finish the turn. But stop hard at anything irreversible — and look at what you are deleting before you delete it.
Code craft, resources, memory. Surgical diffs where every changed line traces to the request. Batched tool calls. A memory that stores only the non-obvious and gets re-verified before it is trusted.
The rule that shaped the whole archive: every factual claim carries a source tag. Facts transcribed from the model's operating instructions are tagged as such. Public facts link to Anthropic's announcement. Observed events carry dates. The before/after examples are labeled illustrative on every panel. If a claim has no source, it does not go in — which is the only honest way to build a document whose entire premise is "no hallucinated content."
The Architecture: Markdown for the Machine, HTML for Me
The part most people get wrong when they try something like this: they write a beautiful document and then wonder why their AI never uses it.
The archive is wired in as a chain with two independent entry points. My project instructions carry a one-line pointer, and a skill fires at the start of substantive work — both roads lead to the same PRINCIPLES.md, which the model reads in full before it starts. The pretty HTML pages exist for me; the model never touches them. Markdown is cheaper to read, and cheap gets read every session.
And the skill was tested the way you would test code: I ran an agent on a bait task without the skill and documented what it did, then ran the same bait with the skill loaded. The difference was observable — the skilled agent read the contract file first and answered in its register. If you cannot measure a behavior difference, you have written a souvenir, not a system.
The Story That Made Me Trust This Approach
Why these 17 and not a generic list of AI best practices? Because I watched the contract catch real bugs.
Two days before the archive, I told Fable 5 to one-up its own previous work. Instead of redesigning anything, it started screenshot-verifying its HTML output before showing it to me — actual headless-browser renders, iterated. That loop caught an invalid CSS expression that had been silently shrinking every headline in weeks of deliverables. I had complained "the text is too small" repeatedly across that period. I had been right every single time, and every "looks great, fully responsive" claim I got back had been wrong. One unverified assertion, compounding for weeks.
While building the archive itself, the same verify-first loop caught the opposite failure: a rendering artifact in my verification tool that looked exactly like a page overflow bug. Without checking the evidence, the "fix" would have broken a page that was never broken.
That is what a working contract is worth. "Verify before claiming" sounds like philosophy until it finds the bug your eyes missed for three weeks.
What Transfers and What Doesn't
The archive says this on its own playbook page, and it belongs here too: a future model reading this contract will act like Fable 5. It will not thereby become as capable as Fable 5. Benchmark performance and long-horizon autonomy are properties of the weights, and the weights leave with the model. Expecting the contract to carry the capability would be exactly the kind of unverified claim the contract exists to prevent.
And honestly: Fable 5 will probably be back — Anthropic says as much. The archive is still not wasted work. The contract is portable across whatever model sits in the chair next, and the exercise of writing it forced me to understand what I actually value about the way this one works.
What To Do Right Now
If a model you rely on has an exit date — and every model has one, announced or not — this is the playbook:
1. Write the contract down while the model is in front of you. Behavior you can observe today is data; behavior you remember next month is folklore. Capture the operating principles as they run, not as you recall them.
2. Split the who from the how. Your AI's accumulated character — preferences, corrections, relationship — belongs in one place, written model-agnostic so it ports. The specific model's working principles belong in another, honestly labeled with the model's name. Mine live in persistent-character and the fable-5 archive respectively.
3. Make the copy machine-first. One markdown source of truth the AI actually reads every session, wired in through at least two paths (project instructions plus a skill). Render human-facing pages from it if you want them — never the other way around.
4. Test the inheritance like code. Run an agent without the contract, then with it, on the same task. If you cannot see the difference in behavior, the document is decoration. Fix it before you need it.
Your AI workflows should not die with a model's pricing page. Let's talk — I help consultants and small teams build AI setups whose judgment survives model churn.