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:
- Laws, not tips. Every rule has a number, a never, or a command that checks it. Anything softer gets optimized away.
- Nothing grades its own homework. The planner, the worker, the verifier, and the gate are four different parties, and the last one is deterministic.
- 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
1claude CLI (Claude Code) with Fable 5 access # usage credits enabled, /usage-credits cap set2llm CLI + OpenRouter key # llm install llm-openrouter3jq, gh, git, make, cron4a repo with a test command
What you are building
1your-repo/2 CLAUDE.md # BUILD 1: the constitution3 loop/4 loop.sh # BUILD 3: the heartbeat5 conductor.md # BUILD 3: routing prompt6 triage.md # BUILD 3: cheap reader prompt7 contract.md # BUILD 2: the three lists8 workers/implement.md # BUILD 39 workers/verify.md # BUILD 310 guardrails/verify.sh # BUILD 2: deterministic gate11 scripts/trust-log.sh # BUILD 412 scripts/log-cost.sh # BUILD 613 scripts/cost-check.sh # BUILD 614 quorum.sh # BUILD 7 (optional)15 verify-goals.sh # BUILD 516 goals/ # BUILD 5: standing goals17 skills/ # BUILD 4: one file per employee18 memory/19 STATE.md trust.tsv goal-ledger.tsv dispatch.tsv usage.log20 Makefile # BUILD 8: tick / queue / trust / audit / dream
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:
Setting
Value
Source
Model string
claude-fable-5
models overview
Context / output
1M tokens / up to 128k output per request
intro docs
Price
$10/M in, $50/M out
intro docs
Thinking
adaptive, always on;
thinking: {type:"disabled"}
is REJECTED; thinking output is summarized-only
intro + effort docs
Effort
low
medium
high
xhigh
max
;
high
= default = omitting the parameter
effort docs
API shape
output_config: {"effort": "..."}
on the Messages API
effort docs
Five official facts that change how you build:
- 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.
- 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.
- 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.
- 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.
- 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:
- Anti-overplanning (for the conductor and any interactive session):
1When you have enough information to act, act. Do not re-derive facts already2established in the conversation, re-litigate a decision the user has already3made, or narrate options you will not pursue. If you are weighing a choice,4give a recommendation, not an exhaustive survey.
2. Anti-gold-plating (for every worker prompt; this is the official fence around over-delivery):
1Don't add features, refactor, or introduce abstractions beyond what the task2requires. A bug fix doesn't need surrounding cleanup. Don't design for3hypothetical future requirements: do the simplest thing that works well.4Don't add error handling or validation for scenarios that cannot happen.5Only validate at system boundaries.
- Grounded progress claims (for any long run; in Anthropic's testing this nearly eliminated fabricated status reports):
1Before reporting progress, audit each claim against a tool result from this2session. Only report work you can point to evidence for; if something is not3yet verified, say so explicitly. If tests fail, say so with the output; if a4step was skipped, say that.
- Autonomous-pipeline reminder (for every cron-driven prompt; kills the "I'll now run X" early stop):
1You are operating autonomously. The user is not watching and cannot answer2questions mid-task. For reversible actions that follow from the original3request, proceed without asking. Before ending your turn, check your last4paragraph: if it is a plan, a question, or a promise about work you have not5done, do that work now with tool calls. End only when the task is complete6or you are blocked on input only the user can provide.
- Official memory format (for the dreamer and memory/learnings/):
1Store one lesson per file with a one-line summary at the top. Record2corrections and confirmed approaches alike, including why they mattered.3Don't save what the repo already records; update existing notes rather than4duplicating; delete notes that turn out to be wrong.
- Official verifier instruction (the docs state it directly: "separate, fresh-context verifier subagents tend to outperform self-critique"):
1Establish a method for checking your own work at an interval of [X] as you2build. Run this every [X interval], verifying your work with subagents3against the specification.
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:
1# CLAUDE.md23## NEVER (laws; exceptions require asking first)4- Never exceed 200 changed lines in one commit without asking.5- Never touch src/auth/, src/billing/, migrations/, or prod config unattended.6- Never report work as done from your own assessment. Done = the check passed.7- Never invent a secret, an endpoint, or a convention. Stop and ask.8- Never add a dependency. Propose it in STATE.md and stop.9- Never exceed effort high inside any loop. xhigh is for one-shot reviews only.10- Never edit or delete a test to make it pass. That is a fail, always.11- Never echo, transcribe, or explain your internal reasoning in response12 text. (Official: triggers reasoning_extraction refusals on Fable 5.)13- When a /goal condition passes, write goals/<name>.md with the condition as14 its predicate before reporting success.1516## DISPATCH (route every task; first match wins; log to memory/dispatch.tsv)17| model | marginal | appetite | intelligence | taste |18|-----------------|----------|----------|--------------|-------|19| claude-fable-5 | 2 (credits) | 3 | 10 | 10 |20| claude-opus-4-8 | 7 (sub) | 6 | 8 | 9 |21| claude-sonnet-5 | 9 (sub) | 8 | 7 | 7 |22| codex (2nd sub) | 9 | 10 | 9 | 5 |231. Decision (plan/review/route/standoff) -> fable-5, effort high, read-only.242. Reads >50k tokens (logs/PDFs/screenshots) -> codex. Never fable.253. Ships to users (UI/API/copy) -> taste >= 8 gets final pass.264. Spec complete -> sonnet-5, effort medium.275. Else sonnet-5; escalate one rung on a miss without asking.2829## WORDS30- "intelligence" = hardest problem handled unsupervised31- "taste" = UI/UX, code quality, API design, copy32- "done" = the predicate passes; nothing else33- "small" = under 50 changed lines; "quick" = under 10 minutes of your time34- "cleanup" = behavior identical, verify.sh green before and after3536## DONE37- Every task has a machine-checkable done_when before work starts.38- A fresh-context agent that saw neither plan nor draft verifies against it.39- guardrails/verify.sh has the final vote.40- Deviations: conservative option, log to IMPLEMENTATION.md, continue.41- Maker and checker disagree twice -> stop, queue for a human.
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:
1## acts alone2draft PRs on branches; fix lint/test debt; update STATE.md; label issues34## queues for me5auth, payments, migrations; any skill below "auto" tier; any diff > 400 lines67## wakes me up8verify fails twice on the same item9safeguard router swapped models mid-run10daily budget breached11anything requests a secret12a standing goal is VIOLATED
Create loop/guardrails/verify.sh (edit for your stack):
1#!/usr/bin/env bash2set -e3npm run typecheck --if-present4npm test --if-present5npm run lint --if-present
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:
1You receive recent commits, open issues, and CI runs. Output ONLY findings:2- finding: <one line>3 evidence: <commit/issue/run id>4 status: actionable | informational5No fixes, no opinions. Nothing to report = output exactly "status: quiet".6Anything touching auth, payments, migrations, secrets = always actionable,7noted "contract-sensitive".
Create loop/conductor.md:
1You are the conductor. You do not write code. You do not edit files.21. Read STATE, TRUST LEDGER, CONTRACT below. Do not trust memory of them.32. Pick the ONE highest-value actionable item.4 contract-sensitive, ambiguous, or likely >400-line diff -> action: queue5 nothing worth doing -> action: stop63. Else action: execute, with a spec a mediocre model can follow.7Output ONLY this JSON:8{ "action": "execute|queue|stop", "item": "...", "skill": "<kebab-case,9stable across runs>", "spec": "...", "done_when": ["<verifiable>", ...] }10You are expensive. Be brief. Your output is a decision, not an essay.
Create loop/workers/implement.md:
1You receive a work order (JSON). Execute the spec exactly.2Do the ONE next step toward done_when. Small diffs win.3Missing credential or undocumented decision -> STOP, write the question to4IMPLEMENTATION.md. Never invent secrets or conventions.5Record what you did and why in IMPLEMENTATION.md (3 lines max).
Create loop/workers/verify.md:
1You receive a SPEC and a DIFF, nothing else. Judge only what is in front of you.21. Does the diff satisfy every done_when? Cite lines.32. Anything outside the spec's scope? Instant fail. Deleted/skipped tests? Instant fail.4Output exactly one line: "PASS: <reason>" or "FAIL: <reason>".5The maker was confident. That is not evidence.
Create loop/loop.sh:
1#!/usr/bin/env bash2set -euo pipefail3cd "$(dirname "$0")"4MAX_ITERS="${MAX_ITERS:-10}"5DAILY_BUDGET_USD="${DAILY_BUDGET_USD:-5}"6CHEAP="${CHEAP:-openrouter/deepseek/deepseek-v4-flash}"7WORKER="${WORKER:-openrouter/moonshotai/kimi-k2.6}"89./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 31011for ((i=1; i<=MAX_ITERS; i++)); do12 # 1 TRIAGE: quiet-tick gate, ~$0.0113 { git log --oneline -20; gh issue list --limit 20 2>/dev/null || true; \14 gh run list --limit 10 2>/dev/null || true; } \15 | llm -m "$CHEAP" -s "$(cat triage.md)" >> memory/STATE.md16 ./scripts/log-cost.sh triage 0.0117 grep -q "status: actionable" memory/STATE.md || { echo quiet; exit 0; }1819 # 2 CONDUCT: Fable, xhigh, fresh context, read-only, JSON out20 claude -p "$(cat conductor.md)21STATE: $(cat memory/STATE.md)22TRUST: $(./scripts/trust-log.sh --render)23CONTRACT: $(cat contract.md)" \24 --model claude-fable-5 --effort xhigh --allowedTools "Read" \25 --output-format json > /tmp/c.json26 ./scripts/log-cost.sh conductor 0.352728 # 2a ROUTE-TOLERANCE: never iterate on a model you didn't choose29 SERVED=$(jq -r '.modelUsage | keys[0] // "claude-fable-5"' /tmp/c.json)30 [[ "$SERVED" != *fable* ]] && { echo "rerouted" >> memory/STATE.md; exit 2; }3132 jq -r '.result' /tmp/c.json > work-order.json33 SKILL=$(jq -r .skill work-order.json); ACTION=$(jq -r .action work-order.json)34 [[ "$ACTION" == stop ]] && exit 035 [[ "$ACTION" == queue ]] && { echo "queued: $SKILL" >> memory/STATE.md; continue; }3637 # 3 EXECUTE: cheap worker, isolated worktree38 WT="../wt-$i"; git worktree add "$WT" -b "loop/$SKILL-$i" >/dev/null39 ( cd "$WT" && llm -m "$WORKER" -s "$(cat "$OLDPWD/workers/implement.md")" \40 "$(cat "$OLDPWD/work-order.json")" > IMPLEMENTATION.md )41 ./scripts/log-cost.sh worker 0.104243 # 4 VERIFY: fresh Fable, no tools, sees only spec + diff44 V=$(claude -p "$(cat workers/verify.md)45SPEC: $(jq -r .spec work-order.json)46DIFF: $(cd "$WT" && git diff)" \47 --model claude-fable-5 --effort high --allowedTools "" \48 --output-format json | jq -r .result)49 ./scripts/log-cost.sh verifier 0.405051 # 5 GATE: deterministic; then ledger; ship only at auto tier52 if [[ "$V" == PASS* ]] && ( cd "$WT" && "$OLDPWD/guardrails/verify.sh" ); then53 ./scripts/trust-log.sh "$SKILL" pass54 if [[ "$(./scripts/trust-log.sh --tier "$SKILL")" == auto ]]; then55 ( cd "$WT" && git add -A && git commit -qm "loop: $SKILL" && gh pr create --fill || true )56 echo "- shipped: $SKILL" >> memory/STATE.md57 else58 echo "- review: $SKILL in $WT" >> memory/STATE.md59 fi60 else61 ./scripts/trust-log.sh "$SKILL" fail62 echo "- FAILED: $SKILL in $WT" >> memory/STATE.md63 fi64 ./scripts/cost-check.sh --budget "$DAILY_BUDGET_USD" || exit 365done66exit 1 # iteration cap without stop: check STATE.md
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:
1#!/usr/bin/env bash2# usage: trust-log.sh <skill> <pass|fail> | --render | --tier <skill>3set -euo pipefail4F="$(dirname "$0")/../memory/trust.tsv"; touch "$F"5tier_of() { awk -v r="$1" -v p="$2" 'BEGIN{6 rate=(r>0)?p/r:07 if (r>=20 && rate>=0.95) print "auto"8 else if (r<10 || rate<0.90) print "watch"9 else print "queue"}'; }10case "${1:-}" in11 --render)12 printf "%-20s %5s %5s %6s %s\n" skill runs pass rate tier13 while IFS=$'\t' read -r s r p; do [ -z "$s" ] && continue14 printf "%-20s %5s %5s %5s%% %s\n" "$s" "$r" "$p" \15 "$(awk -v r="$r" -v p="$p" 'BEGIN{printf "%.0f",(r>0)?p/r*100:0}')" \16 "$(tier_of "$r" "$p")"; done < "$F";;17 --tier)18 line=$(grep -P "^${2}\t" "$F" || echo -e "${2}\t0\t0")19 tier_of "$(cut -f2 <<<"$line")" "$(cut -f3 <<<"$line")";;20 *)21 awk -v s="$1" -v r="$2" -F'\t' 'BEGIN{OFS="\t"; f=0}22 $1==s {f=1; print s,$2+1,$3+(r=="pass"); next} {print}23 END{if(!f) print s,1,(r=="pass")?1:0}' "$F" > "$F.t" && mv "$F.t" "$F"24 if [ "$2" = fail ]; then25 runs=$(grep -P "^${1}\t" "$F" | cut -f2)26 [ "$("$0" --tier "$1")" = watch ] && [ "$runs" -ge 10 ] \27 && echo "ALERT: $1 demoted to watch after $runs runs" >&2 || true28 fi;;29esac
- 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:
1predicate: cd $REPO && npm test -- tests/auth 2>&1 | tail -1 | grep -q passing2born: 2026-07-063source: /goal session 2026-07-06 (fix auth flake)4status: satisfied5last-pass: 2026-07-066on-violation: wake me. Do not auto-fix.7retire-when: auth module deleted. Retirement is a human decision, logged.
Create loop/verify-goals.sh:
1#!/usr/bin/env bash2set -uo pipefail3LEDGER="memory/goal-ledger.tsv"; VIOLATIONS=04for g in goals/*.md; do5 [ -e "$g" ] || continue6 grep -q '^status: retired' "$g" && continue7 pred=$(grep '^predicate:' "$g" | cut -d' ' -f2-); name=$(basename "$g" .md)8 start=$(date +%s%3N)9 if timeout 60 bash -c "$pred" >/dev/null 2>&1; then r=pass10 sed -i "s/^status:.*/status: satisfied/; s/^last-pass:.*/last-pass: $(date +%F)/" "$g"11 else r=FAIL; VIOLATIONS=$((VIOLATIONS+1)); sed -i "s/^status:.*/status: VIOLATED/" "$g"; fi12 echo -e "$(date -Is)\t$name\t$r\t$(( $(date +%s%3N) - start ))" >> "$LEDGER"13done14[ "$VIOLATIONS" -gt 0 ] && { grep -l '^status: VIOLATED' goals/*.md; exit 1; }15echo "all standing goals hold"
Start the sentinel (detection only; fixes go through the normal pipeline):
1/loop 1d Run ./verify-goals.sh. If non-zero: for each violated goal, read its2last-pass date and list what merged since (git log --oneline --since=<date>).3Report goal, suspects, on-violation policy. Do not fix anything.
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:
1awk -F'\t' '$3=="FAIL"{n[$2]++} END{for(g in n) print n[g],g}' memory/goal-ledger.tsv | sort -rn | head -5 # flakiest2grep <goal> memory/goal-ledger.tsv | awk -F'\t' '$3=="FAIL"' | head -1 # when it broke
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:
1#!/usr/bin/env bash2echo -e "$(date -Is)\t$1\t$2" >> "$(dirname "$0")/../memory/usage.log"
Create loop/scripts/cost-check.sh:
1#!/usr/bin/env bash2set -euo pipefail3F="$(dirname "$0")/../memory/usage.log"; touch "$F"; TODAY=$(date +%F)4case "${1:-}" in5 --budget)6 spent=$(awk -F'\t' -v d="$TODAY" '$1 ~ d {s+=$3} END{printf "%.2f",s}' "$F")7 awk -v s="$spent" -v b="$2" 'BEGIN{exit (s>=b)?1:0}' \8 || { echo "spent \$$spent of \$$2" >&2; exit 1; };;9 --report)10 awk -F'\t' -v since="$(date -d '7 days ago' +%F)" \11 '$1>=since{s[$2]+=$3;t+=$3} END{for(k in s) printf " %-10s $%.2f\n",k,s[k]; printf " TOTAL $%.2f\n",t}' "$F";;12esac
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.
1V=02for m in deepseek/deepseek-v4-flash qwen/qwen-3.6 moonshotai/kimi-k2.6; do3 llm -m "openrouter/$m" -s "$(cat triage.md)" < /tmp/signals.txt \4 | grep -q "status: actionable" && V=$((V+1))5done6[ "$V" -ge 2 ] && exec ./conduct.sh || echo "quorum: quiet ($V/3)"
- Ratchet (install when one number matters). Monotonic improvement or self-revert; the metric may not be gamed; the finished floor becomes a standing goal.
1/goal Reduce `npm run lint 2>&1 | grep -c warning` to 0.2Permissions: edit src/; commit per fix; re-measure after every change.3Walls: the number NEVER goes up; revert any change that raises it or breaks a4test; never edit lint config to lower it.5Timebox: stop after 3 attempts with no movement; report survivors.
- Sparring (install when you ship code daily). Builder and breaker, opposed; neither touches the other's output; disputes go to you.
1/loop 1d [breaker] Read yesterday's merged diffs. Write ONE failing test2exposing a real weakness. Commit under tests/sparring/ tagged @sparring.3Fix nothing. Solid code = say so, write nothing.4/loop 1d [builder] If any @sparring test fails, fix the CODE until it passes.5Never edit, weaken, or delete a sparring test; disputes queue for me.
- Compost (install always, weekly). Failures become laws; three proposals max; human signature required.
1/loop 7d Read this week's exhaust: FAILED in STATE.md, fails in trust.tsv,2FAILs in goal-ledger.tsv, PRs closed unmerged. Extract AT MOST 3 proposals:3a new CLAUDE.md law (quote incidents), a skill fix (same failure repeating),4or a standing goal we lacked. Propose only. Clean week = say so.
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:
1tick: ; ./loop/loop.sh2queue: ; @grep -E "review:|queued:|FAILED:|rerouted" loop/memory/STATE.md || echo empty3trust: ; @./loop/scripts/trust-log.sh --render4audit: ; @./loop/scripts/cost-check.sh --report5goals: ; @./loop/verify-goals.sh6clean-worktrees: ; @git worktree list | awk '/wt-/{print $$1}' | xargs -rn1 git worktree remove --force
Cron, when Week 2 starts:
10 7 * * 1-5 cd /path/to/repo/loop && ./loop.sh >> memory/cron.log 2>&1230 7 * * * cd /path/to/repo/loop && ./verify-goals.sh >> memory/cron.log 2>&1
The 30-day trust schedule
Do not skip graduations; each unlocks the next.
Week
Level
You do
Graduate when
1
L1 report
Builds 1-6;
make tick
by hand daily; read everything
3 consecutive runs route exactly as you would have
2
L2 draft
cron on;
make queue
with coffee; reviews feed the ledger
2 skills cross 20 logged runs
3
L3 ship
make audit
vs the formula; best skill goes unattended
1 week, zero interventions
4
L4 grow
compost signs-offs; approve 1 proposed skill; run the delete pass
you removed something and nothing broke
The runbook. What each alarm means and what to do:
Signal
Meaning
Action
exit 2 (reroute)
safeguard router swapped models mid-run
read the checkpoint; re-run item tomorrow; never iterate on the swapped output
stop_reason: refusal
safety classifier declined (HTTP 200, not an error)
official path: fallback to Opus 4.8 via
fallbacks
or middleware; if it recurs on one skill, audit that skill for reasoning-echo or cyber/bio-adjacent phrasing
exit 3 (budget)
daily spend hit the line
make audit
; find which stage grew; fix the effort map, not the budget
ALERT demoted
an established skill dropped below 90%
read its last 3 fails; usually the spec pattern, not the worker
goal VIOLATED
something finished stopped being true
sentinel gives suspects; fix goes through the normal pipeline
maker/checker standoff x2
neither is presumed right
you decide, or run the standoff-breaker (third fresh reviewer, judges evidence, may not split the difference)
verify-goals timeout
predicate too expensive
that is a violation; cheapen the predicate
The Rules (print this)
- Laws, not tips: a number, a never, or a command that checks it.
- The conductor plans, workers execute, neither verifies. --allowedTools enforces it.
- Agents talk in work orders. done_when = spec + stop condition + future invariant.
- Spend effort where the loop branches. Never above high in a loop.
- The quiet tick costs a penny or the loop costs a grand.
- If a shell script couldn't check it, don't write it as a goal.
- Goals graduate; they do not close. verify-goals.sh runs daily, forever.
- Autonomy per skill: 20 runs, 95%, auto. Demotion automatic and loud.
- Two ledgers: trust (workers) and goals (work). Read both with coffee.
- Compute the metabolism before you cron.
- Contract in the repo: acts-alone / queues / wakes-me.
- Never iterate on output from a model you didn't choose.
- The sentinel detects; the pipeline fixes.
- Quorum before waking Fable. Ratchet then weld. Spar daily. Compost weekly.
- One graduation criterion at a time. Every month, delete something.
- 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.
