How to Build An Agentic OS using Fable 5 (Builder's Guide)

This is a complete A–Z breakdown of Claude Fable 5 what it is and how to use it like a 100x engineer

This will change everything about how you work with Claude

Bookmark these 8 builds before you forget

Introduction

You have the most capable model ever made generally available, and you are still typing prompts at it one at a time. This guide fixes that.

Here is the situation as of July 2026. Fable 5 can run for hours unattended, dispatch its own subagents, and do a week of work in a night. It is also metered ($10/M in, $50/M out through usage credits), it over-delivers when scope is not fenced, and it argues for its mistakes more convincingly than most people argue for their correct answers.

Used casually, it is an expensive way to generate impressive wrong things. Used inside a system, it is the closest thing to an employee you can rent for three dollars a day.

This guide builds that system. Not a philosophy of it: the actual files, in order, with a checkpoint after each so you know it works before you stack the next piece on top.

What you will have at the end:

• A CLAUDE.md the model cannot negotiate with (BUILD 1)
• A daily loop where Fable 5 makes every decision but writes almost no tokens, cheap models do the work, an independent verifier grades it, and a bash script holds the final vote (BUILDs 2-3)
• A trust ledger that grants and revokes autonomy per skill, automatically, based on measured pass rates (BUILD 4)
• A goals directory where everything you ever finish keeps getting re-verified daily, forever, so nothing rots silently (BUILD 5)
• A budget that enforces itself instead of surprising you (BUILD 6)
• Four optional loops (quorum, ratchet, sparring, compost) each with the condition that tells you when to install it (BUILD 7)
• A cron schedule, a runbook for every alarm the system can raise, and a 30-day trust schedule that takes it from supervised to self-extending.

Who this is for. Anyone with a repo, a terminal, and a Claude Code subscription or API key. The examples are code-flavored because loops grew up around codebases, but the goal system and half the loops work on invoices, reports, and reading lists just as well; the predicates are just shell commands.

How to read it. In order, doing the checks. BUILD 0 is the official Anthropic settings and prompt language; everything after it is the system built on top. Each build is 10 to 20 minutes. The 30 days at the end are not reading time; they are the graduated-trust schedule during which the system earns the right to run without you. Total hands-on time: about 2 hours.

The three principles underneath everything, so you can predict any design decision before you read it:

1. Laws, not tips. Every rule has a number, a never, or a command that checks it. Anything softer gets optimized away.

1. Nothing grades its own homework. The planner, the worker, the verifier, and the gate are four different parties, and the last one is deterministic.

1. Nothing that passed once goes unwatched. Finished work graduates into a re-verified invariant. A goal you only verify once is an assumption with a timestamp.

No essays from here on. Eight builds, each with files, commands, and a checkpoint.

Prerequisites

What you are building

BUILD 0: Configure the Engine (from the official Fable 5 docs)

Everything in this build comes from Anthropic's own documentation. Set these before writing any file of your own.

The spec sheet:

Five official facts that change how you build:

1. max_tokens is a hard cap on thinking PLUS response text. At high and xhigh, set it large (start at 64k) or Fable runs out of room mid-thought. Applies to every claude -p call in this guide.

1. xhigh is officially for "long-running agentic tasks (over 30 minutes) with token budgets in the millions." That is the conductor seat and nothing else in this system. The docs also say lower effort on Fable 5 "often exceeds xhigh performance on prior models," so resist upgrading workers.

1. Refusals are HTTP 200. Fable 5 runs safety classifiers (offensive cyber, biology/life-sciences, reasoning-extraction). A declined request returns stop_reason: "refusal" as a SUCCESS response. Your scripts must check the stop reason, not the exit code. Official remedy: configure server-side fallbacks or SDK middleware to re-route to Opus 4.8.

1. Never ask Fable to echo its reasoning. Prompts or skills that say "show your thinking" or "explain your reasoning in the response" trigger the reasoning_extraction refusal category and elevate fallbacks. Audit every old skill for this when migrating. Read the structured thinking blocks instead.

1. Turns are long by design. Hard tasks run many minutes per request at higher effort; autonomous runs extend for hours. Adjust client timeouts and check on runs asynchronously (scheduled jobs, not blocking waits). This is why the heartbeat is cron, not a blocking loop.

The official prompt pack. Anthropic ships tested prompt language for Fable 5's known behaviors. These go into your prompts verbatim; do not paraphrase them thinner:

1. Anti-overplanning (for the conductor and any interactive session):

2. Anti-gold-plating (for every worker prompt; this is the official fence around over-delivery):

3. Grounded progress claims (for any long run; in Anthropic's testing this nearly eliminated fabricated status reports):

4. Autonomous-pipeline reminder (for every cron-driven prompt; kills the "I'll now run X" early stop):

5. Official memory format (for the dreamer and memory/learnings/):

6. Official verifier instruction (the docs state it directly: "separate, fresh-context verifier subagents tend to outperform self-critique"):

Two scaffolding orders from the docs worth obeying: start at the top of your difficulty range (testing Fable only on simple workloads undersells it; give it the hardest unsolved problem and let it scope), and refactor old skills (instructions written for prior models are often too prescriptive for Fable 5 and DEGRADE output; if default performance is better without an instruction, delete the instruction).

CHECK 0: Every claude -p call in your scripts has an explicit large max_tokens where supported; your scripts check for stop_reason: "refusal"; no prompt or skill anywhere says "show your thinking."

BUILD 1: The Constitution (CLAUDE.md)

Why, in one line: Fable follows laws and optimizes around tips, so every line needs a number, a never, or a command that checks it.

Rules for the file: four blocks, under 150 lines, no "think step by step" (reasoning is always on; those are paid tokens), no predefined agent personas (Fable designs better teams than you can predefine), mostly stop signs.

Create CLAUDE.md:

Edit the numbers and paths to yours. Workflow-specific material (PR procedure, release checklist) goes in skills/, not here.

CHECK 1: For every line ask: could the model comply 80% and claim success? If yes, rewrite it with a number or a never. wc -l CLAUDE.md under 15

BUILD 2: Walls and Gate

Why: blast radius must be declared before the first tick, and a bash script must hold the final vote.

Create loop/contract.md:

Create loop/guardrails/verify.sh (edit for your stack):

CHECK 2: ./loop/guardrails/verify.sh runs and exits 0 on your current repo. If it fails now, fix that first; the whole system stands on this script.

BUILD 3: The Heartbeat

Why, in three lines: Fable as worker is a four-figure bill (500k-1M token sessions at $50/M out); Fable as conductor emits 10-20% of tokens while making 100% of decisions. A $0.01 model reads the quiet ticks. Agents hand off through a JSON schema so any model fits any seat.

Create loop/triage.md:

Create loop/conductor.md:

Create loop/workers/implement.md:

Create loop/workers/verify.md:

Create loop/loop.sh:

Exit map: 0 quiet/done, 1 cap, 2 reroute, 3 budget. All labeled, on purpose.

CHECK 3: chmod +x loop.sh guardrails/verify.sh then run ./loop.sh once by hand. Confirm: a quiet repo exits 0 for about a penny; an actionable repo produces work-order.json with all five fields and a verdict line in STATE.md.

BUILD 4: The Trust Ledger

Why: "turn up autonomy as trust grows" is not a mechanism; a TSV with tier rules is. Autonomy is per skill, not per loop.

Create loop/scripts/trust-log.sh:

• Tier rules: auto = 20+ runs AND 95%+ pass, ships unattended. queue = verified drafts wait for you. watch = under 10 runs or under 90%, draft-only. Demotion is automatic and prints to stderr, which cron mails to you.
• Seed the roster: create loop/skills/<name>/SKILL.md for each recurring chore (fix-lint-debt, fix-flaky-test, bump-deps, triage-issues are the standard four). Each file: frontmatter (name, description, when), steps, a "never" list, a verifiable done-when. Every skill starts at watch.

CHECK 4: Run ./scripts/trust-log.sh demo pass 21 times, then --tier demo prints auto. Log a fail on a 10+ run skill and see the ALERT on stderr. Reset: > memory/trust.tsv.

BUILD 5: Standing Goals + the Goal Ledger

Why, in one line: a goal you only verify once is an assumption with a timestamp, so finished goals graduate into invariants that are re-verified daily and logged.

Create one file per finished thing, goals/<name>.md:

Predicate rules: a command; exit 0 = invariant holds; cheap, deterministic, read-only. Adjectives are banned; if a shell script can't check it, the checker can't either. Non-code predicates work the same: find invoices/overdue -mtime +45 | wc -l prints 0, test -s reports/$(date +%Y-%m)-review.md.

Create loop/verify-goals.sh:

Start the sentinel (detection only; fixes go through the normal pipeline):

The graduation law is already in CLAUDE.md (BUILD 1): every passed /goal writes its own standing goal. Finishing IS the enrollment.

Ledger queries you will actually use:

Flaky predicate: quarantine (status: retired, note "needs a better predicate"), never delete.

CHECK 5: Add a goal with predicate: true and one with predicate: false. ./verify-goals.sh exits 1, flips the second to VIOLATED, and both appear in the ledger. Delete the dummies.

BUILD 6: The Budget

Why: daily cost = ticks × triage + hits × (conductor + worker + verifier). At real prices (triage $0.01, conductor $0.35, worker $0.10, verifier $0.40): a daily janitor is ~$2.56/day; a 15-minute babysitter with Fable in the triage seat is $34/day for the identical outcome. The model that reads the quiet ticks decides the bill.

Create loop/scripts/log-cost.sh:

Create loop/scripts/cost-check.sh:

Rules that keep it flat: cadence is a cost decision (halving the interval doubles the floor); the quiet tick must cost cents; effort never above high in loops (xhigh is for one-shot reviews; effort is per step, not per run).

CHECK 6: After a week of ticks, ./scripts/cost-check.sh --report matches the formula within noise. Set DAILY_BUDGET_USD to a number you would not mind wasting.

BUILD 7: The Optional Loops (install when their condition appears)

• Quorum (install when dispatch shows Fable wake-ups that produced action: stop). Three cheap models vote; Fable wakes on 2 of 3. Voters never see each other's answers.

• Ratchet (install when one number matters). Monotonic improvement or self-revert; the metric may not be gamed; the finished floor becomes a standing goal.

• Sparring (install when you ship code daily). Builder and breaker, opposed; neither touches the other's output; disputes go to you.

• Compost (install always, weekly). Failures become laws; three proposals max; human signature required.

CHECK 7: Each optional loop has its install condition written next to it in your notes. Installing them speculatively is how systems bloat.

BUILD 8: Ops

Create Makefile:

Cron, when Week 2 starts:

The 30-day trust schedule

Do not skip graduations; each unlocks the next.

The runbook. What each alarm means and what to do:

The Rules (print this)

1. Laws, not tips: a number, a never, or a command that checks it.

1. The conductor plans, workers execute, neither verifies. --allowedTools enforces it.

1. Agents talk in work orders. done_when = spec + stop condition + future invariant.

1. Spend effort where the loop branches. Never above high in a loop.

1. The quiet tick costs a penny or the loop costs a grand.

1. If a shell script couldn't check it, don't write it as a goal.

1. Goals graduate; they do not close. verify-goals.sh runs daily, forever.

1. Autonomy per skill: 20 runs, 95%, auto. Demotion automatic and loud.

1. Two ledgers: trust (workers) and goals (work). Read both with coffee.

1. Compute the metabolism before you cron.

1. Contract in the repo: acts-alone / queues / wakes-me.

1. Never iterate on output from a model you didn't choose.

1. The sentinel detects; the pipeline fixes.

1. Quorum before waking Fable. Ratchet then weld. Spar daily. Compost weekly.

1. One graduation criterion at a time. Every month, delete something.

1. From the official docs: max_tokens caps thinking plus text, refusals are HTTP 200, never ask for echoed reasoning, old skills degrade Fable, and fresh-context verifiers beat self-critique. Anthropic says so; the system enforces it.

Closing

Thirty days from now, if you did the checks: one loop ships boring work unattended, a goals directory re-verifies everything you ever finished, two ledgers tell you the truth about your workers and your work, and a weekly compost run proposes the system's own next improvement for your signature.

• The model was never the hard part. The hard part was building something around it that stays honest when you stop watching. That is what you just built.
• Start tonight with the twenty minutes that proves it: BUILD 2's verify.sh, BUILD 3's first tick by hand, and one standing goal for the last thing you finished.
• The first time verify-goals.sh catches a silent regression on something you were sure was done, you will not need convincing about the rest.

*Disclaimer*

*This article was written by using the user's notes and edited by Claude Opus 4.8 max. *