The clock, first
Through tonight — July 12, 2026, 11:59pm PT — Fable 5 is included in Pro, Max, Team, and select Enterprise plans for up to 50% of weekly usage limits. From July 13, every Fable session draws prepaid usage credits at $10 per million input tokens and $50 per million output — the steepest price Anthropic has put on a generally available model. Anthropic says it intends to restore Fable to subscriptions "as soon as capacity allows," with no committed date.
So tonight is the cheapest the strongest public model will be for a while. But here's the part that outlasts the deadline: the playbook below is what makes Fable worth it at any price. The window makes it urgent. The method makes it pay.
The mental model: the map is not the territory
An engineer on Anthropic's own Claude Code team put a name on the thing that decides every Fable outcome — finding your unknowns — in a widely shared July field guide. The idea underneath it is old and perfect: the map is not the territory.
Your prompt is a map. The real work — the codebase's actual quirks, the customer's actual need, the constraint you forgot to mention — is the territory. Fable 5 is now capable enough to build exactly what your map says, brilliantly, at length, unattended. Which means when the output misses, the gap was almost never the model's capability. It was the distance between your map and the territory — the assumptions the model can't read off your mind.
Most people respond by writing longer prompts: more detailed maps, drawn from the same incomplete survey. The fix isn't a better map. It's a workflow that surveys the territory — a loop of moves before, during, and after the work that surfaces the unknowns while they're still cheap to fix.
The 8-technique playbook
Eight moves, split across the three phases. Each is small. Together they're the difference between the operators and the tourists.
Make it restate the task — and list its assumptions
Before a single line of work: "Restate what you think I'm asking for, then list every assumption you're making and every question you'd ask if you could." The unknowns it surfaces in thirty seconds are the ones that would have sunk the output three hours in. This is the whole "finding your unknowns" workflow in one move.
Point it at the territory, not a description of it
Real files beat summaries of files. A real example of the output you want beats three adjectives about it. With a million tokens of context, the cheapest quality upgrade in the building is pasting the actual thing — the real error log, the real page, the real customer email — instead of your recollection of it.
Agree on "done" before it starts
Define done as something checkable: tests pass, the page renders at this URL, the number reconciles. A task with verifiable done-criteria converges; a task with vibes-criteria wanders. (This is also the foundation of running Fable unattended — see the autonomy playbook.)
Work in checkpoints, not marathons
Ask for a plan first; approve it; then let it run to the next natural boundary and review. Catching a wrong turn at the plan stage costs one message. Catching it after a three-hour autonomous run costs the whole run.
Correct drift the first time you see it
The model's first small misunderstanding compounds into its large one. When something reads slightly off, stop and fix the understanding — don't let politeness or momentum carry a flawed premise forward another twenty minutes.
Give long runs a memory file
For anything that spans hours or sessions, have Fable keep a running notes file — decisions made, dead ends hit, current state. It's unusually good at maintaining one, and it's the difference between resuming and restarting. (Recipe: memory files.)
Verify against the territory, not the prompt
Check the result against what actually needed to happen — run it, click it, reconcile it — not against whether it satisfied your instructions. The prompt was always the approximation. And never let the model be the only judge of its own work; on long runs it can report finishing work it didn't do.
Harvest the delta
Every gap between what you asked and what you actually needed is a discovered unknown. Fold it back — into your project's standing instructions, your memory files, your checklists — so the next run starts with a truer map. Teams that harvest compound; teams that don't re-pay the same tuition weekly.
Prompting mechanics for Fable 5
The 4-part structure
Every serious prompt has the same skeleton: Context (the real materials — files, examples, constraints of record), Goal (the outcome in one plain sentence), Constraints (what must not change, what to avoid, the budget), and Done (the checkable finish line). Fable rewards this structure more than any predecessor because it will actually use all of it. Full recipe: prompting Fable 5.
Here is the difference in the wild. The tourist prompt: "Improve the checkout page, it feels clunky." The operator prompt:
# CONTEXT
The checkout page is checkout.html (attached), served at /buy.
Analytics: 61% of mobile users abandon at the shipping form.
Our design system: paper background, Fraunces headings (see index.html).
# GOAL
Cut the mobile shipping-form abandonment by making the form
completable in under 60 seconds one-handed.
# CONSTRAINTS
Do not change the payment provider markup between the PAYMENT
markers. Keep the page under 80KB. No new dependencies.
Before writing anything: restate the task and list your assumptions.
# DONE
The form has ≤5 visible fields on mobile, autofill attributes on
every input, the page passes the existing checkout.test.js, and
you show me a before/after of the field count.Same request. The first produces a redesign you'll argue with; the second produces a diff you can check. Notice Technique 01 embedded in the constraints — the operator asks for unknowns inside the prompt, every time.
The 5 rules that move quality
1. One task per message — Fable will happily attempt your five-part run-on, and dilute all five. 2. Show, don't describe — an example output is worth fifty adjectives. 3. Say what not to do — negative constraints are cheap and it honors them. 4. Set effort deliberately — the effort dial is also the price dial; high for decisions, low for legwork. 5. Ask for unknowns before work — Technique 01, every time it matters.
The 3 habits to drop today
Drop the mega-prompt — the 800-word prompt-and-pray monolith is a long map of unsurveyed territory. Drop "make it better" — vague dissatisfaction produces vague revision; name the one thing that's wrong. Drop re-explaining — if you've told it the same context three times this week, that context belongs in a file, not in your typing fingers.
The autonomy playbook
Fable 5 can run for hours or days. Whether it should depends entirely on the structure around it — because the two failure modes of unattended runs are drift (it wanders off your intent) and false confidence (it reports work it didn't finish). The playbook, condensed to its five load-bearing rules:
1. Rules must be checkable. Write a short constitution the model reads every run — and every line must contain a number, a "never," or a command that verifies it. "Be careful" is invisible to a model under load; "never commit to main; tests must pass; touch at most 20 files" is enforceable by a five-line script.
2. Nothing grades its own work. The agent that plans gets no write permissions; the agent that executes can't approve itself; verification runs on a different model with fresh context; and the final vote on "done" belongs to a plain script — because a script cannot be talked into a yes.
3. Autonomy is earned, not switched on. A task type runs unattended only after it has logged real runs at a high verified pass rate — and it loses that permission automatically the moment quality slips. Start every new task type supervised; promote on evidence.
4. Budgets are walls, not advisories. Cache the stable context, give each task a token ceiling, and put a hard daily spend cap in a script that halts the loop. A runaway run should hit a number, not your patience.
5. Done is a state, not an event. Finishing a task should register a daily re-check that the result is still true. Long-running agents don't just build things; they quietly break things they built last month — unless something re-verifies.
Operational realities
The Opus 4.8 fallback. Fable ships with a strict safety classifier; some flagged requests — including occasional false positives on routine coding — hand off to Claude Opus 4.8 with a notification. Design for it: keep prompts plainly benign, and treat Opus as your review tier anyway (it's half the price).
The pricing math, exactly. $10 per million input tokens, $50 per million output — 2× Opus 4.8 ($5/$25), versus roughly $3/$15 for Sonnet 5 and $1/$5 for Haiku 4.5. Worked example — one substantial coding task (200k tokens read, 30k written):
All-Fable, no caching: 200k × $10/M + 30k × $50/M = $2.00 + $1.50 = $3.50
Ten naive parallel copies: each re-reads the same 200k ≈ $21.50
Laddered (the operator way):
Fable decides + plans: 30k in (cached) + 3k out ≈ $0.20
Haiku executes: 200k in + 27k out ≈ $0.34
Opus reviews the diff: 40k in + 2k out ≈ $0.25
total ≈ $0.79Same work, 4× cheaper than naive single-Fable and 27× cheaper than naive fan-out — and the effort dial moves each of those lines another several-fold in either direction. This is why "the architecture is the price tag" isn't a slogan; it's the bill. Interactive version with your own numbers: the cost calculator.
The availability risk. This model has already been switched off worldwide once — nineteen days in June, under a US export-control directive — and its subscription window has moved twice. The lesson isn't fear; it's substitution: keep your model IDs in one config file, so a reroute, repricing, or suspension is a one-line edit instead of an emergency.
The five bets for the second half of 2026
Bet 1 — Tonight: run your hardest real task. Not a toy. The gnarliest ticket, migration, or document you have. You'll learn more about where Fable pays in one honest task than in fifty demos — and tonight it's included.
Bet 2 — Install the workflow, not just the model. The eight techniques above, plus the starter-kit skill, into your actual environment. The workflow is the moat; the model is rented.
Bet 3 — Ladder your models. Fable decides, Opus reviews, cheaper models execute. This single architectural habit is what makes the 2× premium profitable instead of painful once credits begin.
Bet 4 — Make your own work legible to agents. Your customers are starting to send AI readers ahead of them. Structured facts, plain answers, machine-readable surfaces — the businesses that speak to both readers get carried home in the answer.
Bet 5 — Keep a ledger. Write down what each Fable-assisted project actually cost and actually returned, monthly. In six months you'll know precisely where the frontier model earns its keep for you — which is the only benchmark that matters.
The window closes tonight. The gap between operators and tourists stays open all year — and it's made of workflow, not tokens.
The downloadable: install the workflow
Everything above compresses into files you can install in about two minutes. The starter kit (~14 KB, MIT) contains the runnable ops/ scaffold — constitution, checker script, heartbeat loop, trust ledger, budget guard — plus a Claude Skill that teaches your environment the whole surface-the-unknowns-then-verify workflow.
# 1. Download and unzip at the root of the repo your agent works in
curl -LO https://fableguide.com/agent/starter-kit/agentic-os-starter.zip
unzip agentic-os-starter.zip
# 2. Install the skill (Claude Code reads skills from .claude/skills/)
mkdir -p .claude/skills
cp -r skill/agentic-os .claude/skills/
# 3. Wire the final vote into git, and make the scripts runnable
chmod +x ops/*.sh
ln -sf ../../ops/check-constitution.sh .git/hooks/pre-commit
# 4. Prove it works before you trust it (Layer-01 checkpoint):
git checkout main && bash ops/check-constitution.sh # must FAIL — that's the pointFrom then on, asking your agent to "set up the agentic OS" or "find your unknowns before starting" invokes the installed workflow: restate the task, list assumptions, agree on checkable done-criteria, work in checkpoints, verify against the territory. Adapt ops/CONSTITUTION.md to your own rules — every rule you add needs its check added in the same commit, or it isn't a rule yet.