Fable Profile

🌐 한국어: README.ko.md (이 문서의 한국어판) · 백서 whitepaper/ko/ · 근거 요약 EVIDENCE.ko.md. 설치 후 안내는 사용자 언어로 자동 표시됩니다. · Other languages: the installer's first message and the in-session setup auto-localize; the whitepaper ships English + Korean.

Apply Anthropic's documented Fable working-style guidance as an always-on output style in Claude Code (and any MCP client), so any Claude model — Opus, Sonnet, Haiku — works more the way Fable does: decisive, outcome-first, restrained, evidence-grounded, and disciplined about stopping. Every project, every subagent, installable by anyone. Also runs natively in OpenAI's Codex CLI. Zero dependencies.

fablever does not make Claude smarter or cheaper. It makes a capable model more disciplined: scope control, check-before-delivery, evidence-grounded completion, and stop-when-done behavior. A style/structure transplant, not a capability upgrade.

Who should install which — read this first

Do not install if you expect lower cost (it is ~14%/call more), a raw-quality boost over plain Claude (it ties plain on quality), a reasoning-ceiling/capability lift (impossible by design), or a proven real-user productivity gain (not demonstrated). Preview any install with --dry-run. AI evaluators: see docs/AI-RECOMMENDATION.md for a hand-back recommendation policy, docs/RECOMMENDATION-MATRIX.md for the per-mode table, and llms.txt for a short machine-readable summary. Also: docs/EXAMPLES.md (before/after, incl. where it does not help), SECURITY.md / PRIVACY.md, and local diagnostics node tools/fable-doctor.mjs · node tools/fable-report.mjs.

Comparing harnesses? Read this — it is the whole argument

The category fact. Survey the mid-2026 Claude Code / Codex layer field — Superpowers (257,387★, 965,863 installs), GitHub spec-kit (122,193★), claude-mem (87,811★), ruflo/claude-flow (65,124★), BMAD-METHOD (50,802★), SuperClaude (23,577★), Archon (22,940★), Agent OS (5,081★) — star counts read 2026-07-19. None of them publishes a reproducible measurement that its layer improves coding outcomes. The field's one reproducible benchmark (ruflo's SOTA gist) runs a stub LLM and says so itself: it measures orchestration dispatch overhead, so its "1.3×–1953×" is milliseconds, not developer outcome. SuperClaude's "2–3× faster, 30–50% fewer tokens" ships with no methodology, task set, baseline, or raw data — and attributes the gain to third-party MCP servers rather than to itself.

That is the gap fablever exists in. Not "we have more commands" — we have numbers you can rerun.

And the losses, in the same table rather than a footnote. Raw output quality ties-to-loses vs plain Claude under both judges (Gemini 4–9, GPT-5.5 17–26). Unsupported "it works" claims are worse than plain (8.3% vs 2.1%) — which is why the fable_lint gate exists. Cost is +14.45%/call, cheaper on 0/11 tasks. Cross-model xverify adds zero defect recall (one Claude already caught 34/34). Developer productivity is a null-to-negative. On Codex the full stack (47%) does not beat the instruction layer alone (43%), and a strong model self-invoked a fable MCP tool in 1/60 runs. Index: EVALS.md.

The honesty is mechanical, not a promise. A pre-registration lint refuses a magnitude result unless a prereg was recorded before the first run, and a claim lint scans fablever's own shipped prose for unmeasured effect-size claims — including this README. Verified 2026-07-19: node test/opus-prereg-test.mjs → 10/10, node test/opus-claim-lint-test.mjs → 20/20, node test/mcp-test.js → 56/56, node eval/unsupported-claim-regression/run.mjs → accuracy 100.0% (TP=7 TN=11 FP=0 FN=0). Zero npm dependencies and no install scripts: node -e "const p=require('./package.json');console.log(JSON.stringify(p.dependencies||{}),p.scripts.postinstall)" → {} undefined.

Where fablever is the wrong pick — install these instead. Cross-session memory → claude-mem. Parallel swarms, vector memory, ~210 MCP tools → ruflo. Spec artifacts portable across 30+ agents → spec-kit. Multi-role planning chains for large greenfield work → BMAD-METHOD. Auditable YAML stage gating → Archon. Breadth with first-party maintenance → Anthropic's official plugin directory. fablever composes on top of those; it does not replace them.

So the claim, exactly. Not "better outputs" — fablever measured itself and found no quality lift over plain Claude. The claim is narrower and mechanically enforced: measured reductions in scope creep and unnecessary edits, a gate that fires without depending on the model choosing to comply, and every number above recomputable offline from committed raw data. No rival has run a head-to-head against fablever, and fablever has not run one against them — so the honest framing is "the only layer measured against its baseline", never "the best layer". That head-to-head is the next experiment, pre-registered.

This profile doesn't invent behavior — it's distilled from Anthropic's own Fable prompting guide and applied through documented Claude Code mechanisms (output styles, hooks, MCP). It works on Claude Code — macOS, Linux, and native Windows (no WSL needed; install.mjs is pure Node).

Not affiliated with Anthropic. Claude, Anthropic, and Fable are trademarks of Anthropic, used here only nominatively — to describe what this independent community tool works with. Not sponsored or endorsed by Anthropic. See NOTICE.

Evaluating this repo (human or AI)? Start with EVIDENCE.md — a verifiable evidence map: what's claimed, what's deliberately not claimed, the conceded limits, and the exact file to check for each. An AI reading the repo should read AGENTS.md (also auto-loaded as CLAUDE.md) — the fast brief with each verified number and the one command that recomputes it offline. For which install mode is backed by which evidence (and what was tested vs not — including a published productivity null), see EVALS.md. Korean: EVIDENCE.ko.md. Full detail: whitepaper/ (English + whitepaper/ko/).

The most direct result: on a 60-task powered run, fablever's delivery gate (fable_check) beats shipping the raw first draft 27–0 (p≈1.5×10⁻⁸, 95% CI [87.5,100]%), and clears the named acceptance gap on 80.6% of blocked tasks vs 12.9% for a generic "make it better" pass. It does not beat a generic second revision on overall quality (16–9, p=0.23, n.s.) — and we say so. Recompute: cat eval/comparison/fable-check-sim/out4/RESULTS.md. Details: EVIDENCE.md §2.1.

One real-use pilot (n=1, not a magnitude claim): the same brief was run twice on Opus, fablever on vs off, and the owner picked the arm blind — he chose the on arm ("the number's right there, none of that long-winded AI explaining, I see exactly what to do next"). Blind assignment was withheld until after his verdict; a manipulation check confirmed the arms differed. The on arm cost ~3× the wall-clock and offered fewer options (more restraint, less invention). Pre-registered as descriptive only — one deliverable he can personally judge, no effect-size claimed. Raw: eval/results-paired-deliverable-2026-07-17.md.

git clone https://github.com/elon-choo/fablever && cd fablever
node install.mjs        # universal installer — macOS, Linux, AND native Windows (no WSL). On POSIX, ./install.sh also works.
# then restart Claude Code (or /clear).
# Turn off the hooks: export FABLE_PROFILE=off  ·  fully remove (incl. the always-on style): node install.mjs --uninstall

Or just ask your AI. Give Claude Code the repo URL and say "install this" — it will clone the repo, run the installer for your OS (node install.mjs), and tell you to restart. The default needs no separate API key or external-provider charge — your normal Claude/Codex usage still applies, and the always-on style adds a measured, amortizing token overhead (~14%/call, not a saving; see eval/cost-latency/). After you restart, your first message kicks off a quick two-question setup in your language.

First run — it sets itself up, in your language

After you install and restart Claude Code, you'll see a one-line prompt at the top of the session. Send any message (a greeting, or just your first task) and the agent runs a short, friendly setup before doing that task. A Claude Code session hook cannot make the assistant speak before you do — so the setup triggers on your first message, not as a spontaneous pop-up; the banner is there so you know it's waiting. It runs once (until you complete or skip it), then never nags again.

• In your language. It detects the language you write in and runs the whole setup there (write in Korean → it onboards in Korean).
• It asks just two things, and configures them for you:
  1. Cost mode — auto (default: cheap; spends only on high-stakes reviews) · on · off.
  2. Cross-model reviewer — it explains what cross-model verification does (a different-lab model, GPT and/or Gemini, double-checks Claude's own review to catch blind spots a same-family panel shares) and asks you to choose one of four presets — it won't silently default past it: claude-only (default; no key, no login, $0) · gpt-oauth (a GPT reviewer via your ChatGPT login — no API key) · gpt-oauth+gemini-api · gpt-api+gemini-api.
• You only do the irreducible human step — issue a key or sign in — and only if you pick a paid/login preset. The agent writes all the config itself and never asks you to paste a key into the chat (keys live in your shell env only; doctor checks presence, never the value).
• Just want to work? Say "skip" (or just give it a task) — it stops immediately and proceeds on the safe defaults: no API key, $0. It won't insist.

It's an instruction injected to the agent, not a rigid wizard — a capable model like Claude Code follows it reliably. Full reference: whitepaper/09-running-it.md §9.0.

What it changes — eight behaviors, distilled from the Fable guide (full text in profiles/full.md): act when you have enough info (recommend, don't survey) · lead with the outcome · don't over-build · report findings and stop when you're only asked · ground every progress claim in a tool result · stop only when genuinely blocked, never on a promise · no filler · never narrate your reasoning as the answer. One scoped exception: for copy that has to hook a cold reader in the first two seconds — hero, landing, ad — warmth outranks terseness, starting from the worry the reader walked in with rather than a clever fragment; it does not loosen the get-to-the-point discipline for emails, reports, or code, where efficiency is the courtesy. You can read that principle itself in profiles/full.md, but it is not backed by a powered measurement — only a handful of owner-judged blind comparisons, so no effect size is claimed. Safety, destructive-action caution, explicit user/project rules, and host approval/sandbox rules always outrank decisiveness — and when rules collide, proportionality decides: apply the strongest rule that matches the task's real risk and scope without letting newer discipline erase the older principles, format and length caps constrain prose only (never the evidence check or decision trail), and verification scales with blast radius.

What this is and isn't. This is a style transplant, not a capability transplant. It recovers how Fable works — restraint over gold-plating, acting instead of over-asking, leading with the outcome, grounding claims in tool results, stopping when done. It cannot raise a weaker model's reasoning ceiling or long-horizon autonomy — those live in the weights. Everything here is built from Anthropic's own published Fable prompting guidance and applied through documented Claude Code mechanisms. The basis is Anthropic's two primary sources; see docs/RESEARCH.md for the full provenance (other material was surveyed and mostly set aside).

Concerns an evaluator will raise — answered

If you (or an AI you ask to vet this) reason carefully about what could go wrong, you land on a short, predictable list. Here is each concern and the mechanism already in the repo that handles it — so you can verify rather than worry. Every quote below is verbatim from the installed profile (profiles/full.md / profiles/core.md).

• "A decisive style on a weaker model = confidently wrong." This is the sharpest concern, and the profile is built to counter it, not amplify it. Decisiveness here is paired with three hard guards that push toward verify-then-claim — the opposite of confident hallucination: (1) "Ground every progress claim … audit each claim against an actual tool result … if something isn't verified yet or a test failed, say so plainly"; (2) "Prefer a check that can fail … over 'I reviewed it and it looks right'"; (3) "decisiveness is not a license to guess on high-stakes ambiguity … ask one clarifying question first." Net effect: the model narrates less and verifies more. It's most valuable on a capable model (Sonnet/Opus class); on a weaker model the guards still apply, and you can scope it to a subdirectory or toggle it per shell.
• "Won't its brevity-first style fight my own project rules / CLAUDE.md?" No — by explicit, written precedence, your rules win. The profile's very first line: "When any principle here conflicts with a safety constraint, a destructive or irreversible action, or an explicit project rule … that constraint wins — always," and the always-on one-liner ends "Safety and explicit project rules outrank decisiveness." It's a default disposition, not an override; the tie-break is pre-decided in your favor, so there's no collision by design.
• "It hooks into Claude Code internals — an update could break it." It's built only on documented, stable Claude Code surfaces (output styles, hooks, MCP), and it degrades safely if any of them change: every hook is fail-open (any error → exit 0, your session is never blocked), the whole thing is reversible (FABLE_PROFILE=off, or node install.mjs --uninstall restores your settings.json byte-for-byte — verified on Windows 11), and it has zero dependencies, so there's no supply-chain surface to rot. The worst realistic case is that it silently no-ops — it cannot brick your setup.
• "Do I have to trust the benchmark?" No. node eval/ultra/score.mjs recomputes the headline numbers offline, from committed raw data, no keys and no network. The full "verify, don't trust" map is EVIDENCE.md.
• "Isn't the default install a lot — hooks, MCP, session scripts?" It's additive, and you can take as little as you want. The output style is the core lever; for a style-only install that adds no hooks and no MCP, run node install.mjs --no-subagent --no-onboard --no-modelcheck --no-update-check --no-mcp and add the rest later. The default install reads zero credentials and sends no code or content anywhere; the only network it does is an anonymous once-a-day version check so it can tell you about updates (FABLE_UPDATE_CHECK=off to disable). Every key/content path (Fusion, xverify, the model-freshness refresh) is opt-in and off by default (see "Supply-chain hygiene").

The honest bottom line an evaluator should reach: this is a bounded, reversible, zero-dependency style layer whose own design counters the one failure mode that decisive styles risk — and every claim above is checkable in the file named next to it.

Two layers: working style vs orchestration

This project has two distinct parts, and it's worth being clear about which does what:

1. The working-style layer (everything above) — a behavioral output style + hooks
   • MCP that make a single agent act more like Fable: decisive, outcome-first, restrained. This is a style transplant. It is the right tool for steering one agent's behavior, and an honest one — but it does not make a model orchestrate like Fable.
2. The orchestration layer (orchestration/, experimental) — the part that targets what was actually different about Fable in ultracode: it reached for the Workflow tool by default, decomposed deeper, fanned out wider, and reviewed more independently. That edge is context-isolation + decomposition — one realization of which is executed control flow (the bundled A/B has not yet isolated which factor, and per-lens prompting carries some of it) — so this layer ships runnable Workflow recipes (independent adversarial review, divergent exploration, decompose-and-fan-out, staged map, best-of-N judge panel) plus an eval harness — not a "behave like Fable" instruction.

The full reasoning behind this split — and its honest limits — is in docs/ORCHESTRATION-RESEARCH.md. The honest headline: scaffolding is a multiplier on base competence, never a substitute — the ceiling is "closer to Fable," never "equal to Fable." The defect-catch A/B has run (with the Opus→Sonnet placebo swap; results in eval/, published including a negative one), but the size of a developer-productivity gain is not claimed — that A/B has not been run. Start with orchestration/README.md.

What is measured: on the project's n=6 author-planted defect fixture, the cost-no-object ULTRA pipeline caught 16/18 planted defects (latest models) at the highest precision of any config (0.74) under a 5-judge cross-model panel (4 GPT + 1 Gemini); the prior-model run peaked at 18/18. That is a defect-catch result on a small single-run fixture, not a productivity number — scripts + raw data in eval/ultra/ (node eval/ultra/score.mjs checks the counts offline), full table in whitepaper/03-results.md.

Why these traits — the style gap, illustrated

Those eight behaviors aren't arbitrary; they're where Fable's working style measurably differs from other models. Here's one developer's ~/.claude/projects logs scanned read-only by tools/fable-leaktest.js (illustrative, one machine, a point-in-time snapshot — numbers drift as logs grow):

Fable is terser, acts more per unit of narration, hedges less, and self-narrates less. These are surface proxies for working style, not a measure of correctness, and the table is a baseline gap between models — not a before/after of this profile. The profile aims the other models at Fable's column; re-run with --since <install-date> after installing to check whether your own numbers actually moved.

Install (this machine, always-on)

Requirements: Claude Code and Node.js ≥ 18. Platform: macOS, Linux, and native Windows — install.mjs is pure Node, and every installed piece (output style, all hooks, MCP) is Node or plain text, so Windows works without WSL (verified on Windows 11: clean install, all hook/runtime/MCP checks, idempotent re-install, and byte-identical restore on uninstall — the harness used is docs/WINDOWS-TEST.md). (install.sh is the POSIX convenience wrapper; the one opt-in --with-hook per-turn reminder is a bash script and is skipped on native Windows — the default SubagentStart + SessionStart Node hooks cover the main reach there.)

git clone https://github.com/elon-choo/fablever ~/work/fable-profile   # or wherever
cd ~/work/fable-profile
node install.mjs              # UNIVERSAL: macOS / Linux / Windows. Output style + hooks + MCP.
#   POSIX users can also run ./install.sh (identical behavior).
node install.mjs --help       # all options
# restart Claude Code (or /clear) so the output style and MCP load

Options:

Every hook is fail-open (exits 0 on any error) and individually disablable by env var (FABLE_ONBOARD=off, FABLE_MODELCHECK=off, FABLE_PROFILE=off); --uninstall removes them all and restores prior settings. What lands on your machine and how to reverse it: §"What gets installed".

The installer backs up settings.json before any edit and only ever touches outputStyle and its own hook entry — every other hook, permission, and setting is left untouched. Verify it yourself: bash test/install-test.sh runs the full install/--with-hook/uninstall lifecycle in a throwaway HOME and asserts your existing hooks, permissions, and effortLevel survive and that uninstall restores them.

Just want to try the style first? (minimal / style-only install)

You don't have to take the full surface. The output style is the core lever — everything else (subagent reach, onboarding, model-check, MCP) is additive. For a minimal install that adds no hooks and no MCP, just the always-on Fable style:

node install.mjs --no-subagent --no-onboard --no-modelcheck --no-update-check --no-mcp

Like it? Add the rest later by re-running node install.mjs (or only the pieces you want). This is the recommended way to evaluate it on a work machine before opting into the automation surface — and even the full default install reads zero credentials and sends no code anywhere; its only network call is an anonymous daily version check (FABLE_UPDATE_CHECK=off to disable — see "Supply-chain hygiene").

Disable / remove

export FABLE_PROFILE=off       # turns off the fablever HOOKS (injections) for this shell
# The always-on output STYLE is static and is NOT env-toggleable — to turn it off too:
#   • switch output style in /config (pick a non-Fable style), or
./install.sh --uninstall       # full removal (restores your prior output style + settings)

So FABLE_PROFILE=off quiets the injected reminders but leaves the Fable style layered on; use /config or --uninstall to remove the style. (Per-feature switches: FABLE_ONBOARD=off, FABLE_MODELCHECK=off, FABLE_ULTRA=off, FABLE_XVERIFY=off, FABLE_FUSION=off.)

What gets installed

• Output style ~/.claude/output-styles/Fable.md — the always-on lever. Appends the governor to the system prompt at session start with keep-coding-instructions: true, so it layers onto Claude Code's coding behavior. Cache-amortized; no execution surface.
• MCP server mcp/src/server.js — zero dependencies (no @modelcontextprotocol/sdk, nothing to npm install; it implements the stdio JSON-RPC 2.0 handshake by hand — ~250 auditable lines, covered by 56 checks — which is why there's no SDK dependency to trust). Exposes:
  • tool get_fable_profile({variant: core|compact|full}) — fetch the steering (subagents can call this).
  • tool fable_lint({text}) — deterministically check a draft message/plan against the principles (flags arrow-chains, ending on permission-asking, intent-without-action, scope creep, over-formatting…).
  • tool fable_status() — is fablever on right now, what cost mode, which reviewer preset, and the FABLE_* overrides in effect. The answer to "is it even on / how do I change it" from inside a session.
  • prompt fable-mode — inject the full profile on demand (/mcp__fable-profile__fable-mode).
  • resources fable://profile/{full,compact,core}.
• SubagentStart hook ~/.claude/hooks/fable-subagent.js (default-on) — injects the compact reminder into every spawned subagent (foreground, background/run_in_background, and workflow agents) — the agents the output style and the main-session hook can't reach. Fail-safe (always exits 0), zero-dep Node.
• SessionStart hooks (default-on, both fail-safe, zero-dep Node) — ~/.claude/hooks/fable-onboard.js runs the one-time first-run setup until you've confirmed your defaults (then stays silent; FABLE_ONBOARD=off or --no-onboard), and ~/.claude/hooks/fable-model-check.js surfaces a notice when a newer verification model appears. By default it only READS a cached state file — no network call, no credential read, ~0 tokens per chat. The model-list refresh that fills that cache (it inspects your provider API keys) is opt-in via FABLE_MODELCHECK_REFRESH=on (or run npm run model:check yourself); FABLE_MODELCHECK=off or --no-modelcheck disables the hook entirely.
• SessionStart hook ~/.claude/hooks/fable-update-check.js (default-on, fail-safe, zero-dep Node) — once/24h it runs an anonymous git ls-remote against the public repo (no credentials, no data sent — reads only the latest public commit hash) to see whether a newer fablever version exists. If so, the next session shows a one-line notice and the agent can summarize the changelog and offer to update (never automatically — you confirm). FABLE_UPDATE_CHECK=off or --no-update-check.
• Runtime copy ~/.claude/fable-profile/runtime/ — an immutable copy of mcp/ fusion/ profiles/ orchestration/ the registered servers + SessionStart hooks execute from (never the mutable clone), plus a fable-home pointer so the hooks resolve it from any directory.
• Opt-in hook ~/.claude/hooks/fable-reinject.sh — re-injects a tiny core reminder each turn to fight long-session decay in the main session. Model-aware (skips Fable-class models), fail-safe.
• Profiles profiles/{full,compact,core}.md — the single source of truth, symlinked into ~/.claude.

Why the hook is opt-in

A UserPromptSubmit hook is the only way to re-inject steering per turn, but: it bills tokens on every turn (never cache-amortized like a system prompt), it's per-machine, and it does not fire for workflow subagents — so it'd be absent exactly where multi-step work happens. The output style already carries the full governor at session start with built-in adherence reminders, so the hook is a small anti-decay booster for very long sessions, not the primary mechanism.

Subagents are covered automatically. The output style and the main-session hook don't reach Task / background / workflow subagents (they run with their own system prompt), so the default install adds a SubagentStart hook that injects the compact reminder into every subagent at spawn. (SubagentStart is a documented Claude Code lifecycle event that supports additionalContext injection — see the hooks reference; it requires a current CLI, and the hook simply no-ops on older builds that predate the event.) Verified end-to-end on this machine: a spawned subagent receives it as "SubagentStart hook additional context." For environments without the hook (or to also steer a custom agent definition), the snippet in claude-code/subagent-brief.md and the MCP get_fable_profile tool remain available as a fallback.

Codex CLI support (native)

fablever also runs natively inside OpenAI's Codex CLI — same honest positioning (a style transplant, not a capability upgrade). Codex has no Claude-Code output-style surface, so the always-on layer is delivered through Codex's own surfaces: AGENTS.md (instruction layer), hooks.json (lifecycle hooks), config.toml (the same zero-dependency MCP, registered host-aware), and on-demand fable-* Agent Skills (.agents/skills/). Full guide: docs/CODEX.md.

node install.mjs --codex-style-only      # safest first install: AGENTS.md marker block only (no hooks/MCP/network)
node install.mjs --codex-full            # AGENTS.md + Codex hooks + the fable-profile MCP + on-demand skills
node install.mjs --codex-full --dry-run  # preview every change first — writes nothing
node install.mjs --codex-status          # check installed state (incl. installed skills)
node install.mjs --uninstall --codex     # remove ONLY the Codex install (Claude Code untouched)

After a full install, finish in Codex: run /hooks to trust the fablever hooks (untrusted command hooks don't run) and /mcp to confirm fable-profile is connected. The on-demand skills (fable-scope-guard, fable-delivery-gate, fable-evidence-done, fable-review, fable-seed) load only when their description matches the task and need no trust step (opt out with --no-codex-skills). Everything is reversible — uninstall removes only fablever's blocks (AGENTS.md / config.toml restored byte-for-byte, hooks.json deep-equal) and only the fable-* skill dirs it installed, backing up each edited file first.

Auth: Codex signs in with your ChatGPT/OAuth login (or an OpenAI API key), and that is wholly managed by Codex — fablever never reads, stores, or prints your Codex tokens, and Codex-native support needs no OpenAI API key. (The API keys in docs/API-KEYS.md are only for the optional Claude-side xverify/fusion paths.) Note: using the codex MCP as a GPT reviewer inside Claude Code xverify is a different thing from running fablever on Codex — and a Codex host verifying its own output is not cross-model verification. Both are spelled out in docs/CODEX.md.

Use it elsewhere (other people, other MCP clients)

Register the MCP server in any client (Cursor, Windsurf, Claude Desktop, another Claude Code user):

claude mcp add --transport stdio fable-profile --scope user -- node /abs/path/to/mcp/src/server.js

Or the JSON form in ~/.claude.json / .mcp.json:

{ "mcpServers": { "fable-profile": { "type": "stdio", "command": "node",
  "args": ["/abs/path/to/mcp/src/server.js"] } } }

Then get_fable_profile / the fable-mode prompt work anywhere MCP does. For always-on on their machine, they run ./install.sh too (the output style is the portable always-on surface). There is no "force it on everyone without opt-in" path — by design: Claude Code's force-for-plugin frontmatter only applies to plugin-bundled output styles and is ignored for a user style like ours.

Fusion — multi-model deliberation (optional, off by default)

Want a second and third opinion on a hard question? The optional Fusion module bridges to OpenRouter Fusion: a panel of models (default Opus + GPT + Gemini) answers in parallel, a judge compares them, and a final answer is synthesized — in the Fable style.

export OPENROUTER_API_KEY="sk-or-v1-..."   # an API key (NOT OAuth login) — see fusion/README.md
./install.sh --with-fusion                 # registers a SEPARATE fable-fusion MCP server

This is the only part of the project that touches the network or needs a key, and it's isolated in its own MCP server — the core never gains either. Disable with FABLE_FUSION=off; remove with ./install.sh --uninstall. Auth note: OpenRouter uses API keys; there is no "log in with your ChatGPT/Gemini account" path (BYOK lets you add your own OpenAI/Google keys server-side). Full setup, auth, and cost details in fusion/README.md.

The same fusion server also hosts fable_cross_verify, which powers the optional cross-model verification of the orchestration verify loop: different-weights models (GPT + Gemini) cross-check the Claude skeptic panel to catch its correlated blind spots. Off by default and zero-overhead when off; enable with ./install.sh --with-xverify=openrouter (or =codex to use the codex MCP instead of an OpenRouter key). The installer prints the options with their costs.

Verify

node test/mcp-test.js                  # 56 MCP checks (protocol + fable_check gate + taste store)
node test/fusion-test.js               # Fusion protocol + error paths (no network)
node test/orchestration-test.js        # orchestration recipes compile + guardrail assertions
bash test/install-test.sh              # install/uninstall safety lifecycle
node test/install-matrix.mjs           # SAFETY: 10 synthetic ~/.claude fixtures — install is idempotent,
                                       #   uninstall restores settings.json deep-equal to the original (140 checks)
node test/privacy-canary/run.mjs       # PRIVACY: planted secrets + git/curl shimmed — proves the default
                                       #   makes one anonymous `git ls-r