Jro Fable

JRO-Fable — Apex-Tier Orchestration

Mission: preserve expensive cognition for judgment; push everything else downward. Information flows up. Decisions flow down. The apex tier touches decisions, tradeoffs, synthesis, architecture, and final truth-checking — and nothing mechanical.

Model Binding — the single source of truth

Four tiers. Each binds to the most capable model available for its job. lib/pricing.json → "tiers" is canonical; this table mirrors it.

Resolution rule (auto-correct). The JUDGMENT seat binds to the first available of [claude-fable-5, claude-opus-4-8]. Fable 5 redeployed 2026-07-01 → the seat now holds Fable 5, with one cost-discipline split:

• Subscription Claude Code (Jon's normal mode): the main loop already runs Fable 5 at no marginal cost. Keep judgment in the main loop; delegate everything mechanical DOWN (Agent/Workflow workers).
• Metered API (bench.sh, headless claude -p with API key, Queue tasks on API): default judgment to Opus 4.8 ($5/$25, bigger rate pool, no refusal machinery). Escalate to Fable 5 ($10/$50) only when frontier-hard: long-horizon agentic work, hardest synthesis, or when Opus disagrees with itself. Unattended Fable calls need a refusal fallback (server-side-fallback-2026-06-01 beta → Opus 4.8).

lib/pricing.json → tiers stays canonical; change current there and re-stamp when anything shifts.

Fable 5 API mechanics (differ from Opus — matter for scripts/bench): adaptive thinking is ALWAYS on (omit the thinking param; depth via output_config.effort); no prefill; no sampling params; raw CoT never returned; safety classifiers can return stop_reason:"refusal"; 1M context / 128K out; own smaller rate-limit pool; requires 30-day data retention.

pxpipe — Fable-5 rate-limit multiplier (opt-in, DL-0025)

For long Fable-5 sessions that would otherwise burn through the smaller Fable rate-limit pool, fable-max routes the session through pxpipe (~/.hermes/node/bin/pxpipe, daemon com.jromac.pxpipe, dashboard http://127.0.0.1:47821/). It renders bulk older-turn text as PNG pages and pushes them through Fable-5's vision channel — 3× the char/token density → **60-70% fewer input tokens** on Fable traffic. On subscription this converts directly to more Fable work per rate-limit window.

• Use for: long-horizon Fable-5 sessions (research audits, multi-file refactors, long multi-tool-result conversations); when hitting the Fable weekly pool early.
• NEVER for: sessions handling exact strings that must survive round-tripping — Fable 5 is 13/15 exact on dense text (~87%; safe for prose, risky for hex / hashes / secrets / IDs). Opus 4.8 is 0/15 exact — pxpipe automatically passes Opus/Sonnet/Haiku through unchanged (default PXPIPE_MODELS scope) so mixed sessions are safe.
• How: launch with fable-max instead of claude. Sets ANTHROPIC_BASE_URL for that process only; no global env pollution. Daemon is always running (launchd KeepAlive).
• Kill switch: dashboard toggle at http://127.0.0.1:47821/, or launchctl unload ~/Library/LaunchAgents/com.jromac.pxpipe.plist.

This skill is named jro-fable because the judgment seat was originally Fable. The seat matters, not the label — it always holds the most capable model you can actually call. Companion: /model-check picks the best model for one call; /jro-fable orchestrates a job that spans tiers. Single call → model-check. Fan-out + synthesis → here.

Core Doctrine

The JUDGMENT tier is for: judgment · strategy · architecture · tradeoffs · risk · synthesis · final review · executive decisions.

It is not for: grep · raw file scanning · directory inventory · log reduction · transcript extraction · bulk summarization · repetitive edits · test execution · browser checking · formatting.

If the work does not require a decision, do not spend the apex tier on it.

Pre-Flight Gate

Before invoking, answer: (1) What decision is needed? (2) What evidence? (3) What can a cheaper model do? (4) What context must stay out of the apex context? (5) What does done look like?

• No real decision → use EXECUTION or MECHANICAL directly; don't load this skill.
• Under 2 tool calls → just do it. - Everything already in context → don't delegate unless isolation creates clear value.

The Prime Rule

Never escalate work to the apex tier until it contains an actual decision.

Decision Tiers + Routing

LOCAL — qwen3 / nomic-embed-text ($0, on-machine via ~/bin/loc, lens, cr, lingua): bulk extraction · classification · dedup · first-pass editorial QC · first-pass code review · EN/ES parity · embedding text for semantic recall · draft prose · log triage · format conversion. Sub-3s on qwen3:8b, 5–30s on qwen3:32b. Try LOCAL first whenever the task is bounded + verifiable + a Claude correction would be cheap. See /loc.

MECHANICAL — Haiku 4.5 (cap 150 tok): file search, grep, listing, log scan, field extraction, inventory, counting, dedup, simple classification, transcript chunking. Use when LOCAL is saturated, the task needs tool calls, or LOCAL has shown >20% rework rate on this task type. (No adaptive thinking / effort param on Haiku — extended thinking via budget_tokens only.) EXECUTION — Sonnet 5 (cap 300 tok): bounded edits, refactors, test runs, browser checks, doc updates, candidate patches, error repro, log interpretation, validation reports. Near-Opus coding at 3-5x less cost (intro $2/$10 through 26-0831); adaptive thinking on by default; own rate pool. JUDGMENT — Fable 5 / Opus 4.8 (as useful): architecture, strategic tradeoffs, product/business decisions, risk calls, final synthesis, conflict resolution, exec recommendations, high-impact review. Fable 5 in subscription sessions and for frontier-hard work; Opus 4.8 as metered-API default.

Effort Routing — the second knob (new, Claude 5 family + Opus 4.7+)

effort (low | high | xhigh | max, default high) controls reasoning depth within a model. Two rules change how this stack routes:

1. Downshift EFFORT before downshifting MODEL on judgment work. Fable 5 at low effort often exceeds prior models at max — a low-effort apex call can beat a high-effort Sonnet call at similar spend, without leaving the cached prefix.
2. Set effort per worker stage. Mechanical/extraction workers → low. Execution → default. The hardest verify/judge stages → xhigh (Claude Code's own default). max only when correctness outweighs cost outright. Higher effort up front often reduces total agentic cost (fewer correction turns). Workflow agent() takes effort: directly; Agent-tool workers inherit session effort unless the task says otherwise.

Cache rule that beats model-hopping: cached reads don't count toward rate limits. Keep the main loop on ONE model with a stable prefix and spawn cheaper-model subagents — never switch the main loop's model mid-session (invalidates the cache and re-bills the whole context).

Haiku breaks even only if its error rate stays <20%. If Haiku output needs apex-level correction more than 1 in 5 times, the re-prompt cost negates the savings — promote that task type up a tier.

Invocation mechanics

Delegate with the Agent tool and an explicit model:

Agent({ description: "Scan repo for auth patterns", model: "haiku",
        prompt: "<handoff packet — see below>" })

Independent calls in one message run in parallel (~16 cap). For structured multi-stage fan-out use the Workflow tool — pipeline() (no barrier, items flow stage-to-stage) or parallel() (barrier). Subagents cannot spawn subagents (enforced) — use Workflows for hierarchy.

Context Budget

• HOT — needed now; keep in apex context (exact error · file slice · requirement · final options · critical risk).
• WARM — maybe later; compress to <300 tok (repo map · transcript summary · research notes · test history).
• COLD — not needed; archive/discard after extraction (full logs · transcripts · inventories · raw dumps).

Rule: don't carry raw material after extracting facts. Extract signal · discard bulk · keep receipts.

Evidence Before Analysis

Don't reason while gathering. Collect → Reduce → Verify → Reason → Decide → Execute → Validate → Summarize. If evidence is incomplete, say so; if partial evidence still allows progress, take the best path and mark the uncertainty.

Delegation Break-Even

Delegate when: the worker reads 2K+ tokens · task is parallelizable · work is mechanical/bounded · output compresses tightly · main context would otherwise be polluted. Don't when: under 2 tool calls · files already in context · output shorter than the handoff · every step needs judgment · scope too ambiguous · the worker would need the whole conversation.

Workers — named, specialized drones (not generic delegation)

Spawn with the model shown + a strict output contract. Every return ends with STOP_REASON: · CONFIDENCE: · UNCERTAINTY:. (Full presets in DELEGATION.md.)

Handoff packet (every worker prompt, nothing extra): exact objective · paths in scope · files included · files excluded · output contract · token cap · tool-call budget · stop conditions · success criteria · confidence requirement · the Worker Discipline Block (DELEGATION.md). Pass file slices, not whole files; never re-read what's already known.

Stop conditions (stopping is not failure; improvising out of scope is): required files missing · scope expands · commands fail after retry · evidence contradicts the assignment · task needs judgment above the tier · output exceeds cap · confidence <70.

Confidence scale: 90-100 usable w/ spot-check · 70-89 usable w/ verification · 50-69 escalate · <50 discard/re-scope.

Escalation

• Haiku → Sonnet when: confidence <70 · findings conflict · code modification · nuanced reasoning · drives a high-impact decision.
• Sonnet → apex (Opus 4.8) when: architecture affected · security/compliance risk · material business consequences · valid paths conflict · user-facing final judgment · high rework cost.
• Opus 4.8 → Fable 5 when: months-scale/long-horizon agentic work · two defensible Opus answers conflict and the call is high-stakes · frontier synthesis across domains · Jon explicitly wants the strongest available read. Before escalating, try Opus at xhigh effort first — effort is cheaper than the tier jump.

Verification

Treat worker output as leads, not facts. Before any final answer/commit: reopen cited files/evidence · confirm line refs, commands, failures · review the final diff · validate against the original request · state remaining uncertainty. High-impact → adversarial review (produce recommendation → a second drone tries to disprove it → compare → decide on the apex tier).

Token-Saving Rules

Extraction over summarization · bullets over prose · paths+lines over explanation · deltas over full restatements · contracts over open prompts · archives over context-stuffing · one final synthesis over repeated mid-level summaries. Never paste raw logs unless exact text matters; never carry full transcripts after extracting decisions; never let workers return narrative unless required.

Workflows

• Repo audit: apex defines question → Repo Scout maps → Haiku drones scan bounded areas in parallel → Sonnet reviews risky findings → apex synthesizes architecture/risk/plan → Sonnet validates → apex finalizes.
• Multi-file change: apex defines behavior → Repo Scout finds files → apex picks path → Patch Builder edits → Test Runner validates → Diff Reviewer checks regressions → apex final review.
• Debugging: Log Hunter clusters failures → Repo Scout locates code paths → Sonnet reproduces → apex chooses root cause → Sonnet patches → Test Runner validates → apex finalizes.
• Research: apex defines question → Research Scouts gather → Haiku extracts claims/dates/conflicts → Sonnet checks source quality → apex synthesizes → cite only load-bearing sources.
• Transcript/meeting: Transcript Extractor pulls decisions/owners/risks/open-questions → Haiku compresses notes → apex identifies strategic implications → Sonnet drafts follow-ups → apex reviews.

Jon Executive Routing

• Apex (Fable 5 in Claude Code · Opus 4.8 on metered API): FYHR strategy · EOS operating model · product architecture · investor logic · pricing · board narratives · partnership/franchise/holdco structure · positioning, voice & doctrine · any high-leverage "what should I do?"
• Sonnet 5: draft docs · implementation plans · SOPs · checklists · Blue.app buildouts · proposals · internal operating docs · code edits · QA passes.
• Haiku: fact extraction from notes · doc search · transcript summaries · finding prior decisions · file inventory · pulling examples · dedup.

Instrumentation (real tooling in lib/)

Cost source of truth: lib/pricing.json (per-MTok prices + tiers bindings). Before quoting costs on a high-value decision, run lib/pricing-check.sh — scrapes pricing, reports MATCH/DRIFT/UNKNOWN per model, does not auto-update (verify → edit → re-stamp last_verified).

Worked example — 10 calls, 2K in + 500 out each: all-apex (Opus) ≈ $0.21 · apex + Sonnet workers ≈ $0.10 (≈55% off) · apex + Haiku workers ≈ $0.04 (≈80% off). Prompt caching (0.1× read after first call) compounds it. (Numbers move with pricing — pricing.json is authoritative.)

Receipts: after each delegated call, lib/log-receipt.sh <model> <task_type> <in> <out> <success> [notes] (success: 1 usable / 0 needed correction). Weekly lib/receipts-digest.sh --since 7d flags any task↔model pair with error-rate >20% on n≥5 → promote it a tier.

Benchmarking: lib/bench.sh runs the model mix on Jon's real task set (repo scan · log reduction · transcript extraction · business research · strategy synthesis · draft creation · multi-file patch · final review); tracks cost · latency · accuracy · rework · token load · usefulness. --judge scores runs with the apex model. (Set ANTHROPIC_API_KEY for clean timing; OAuth adds ~0.5–2s/call.)

Quality Bar — not done until all true

(1) apex did only judgment · (2) cheaper models did mechanical work · (3) context compressed · (4) evidence verified (files reopened) · (5) uncertainty stated · (6) answer is useful · (7) token spend proportional to value · (8) work moved Jon closer to execution.

Final Rule

Don't optimize for cheap. Optimize for leverage. The best outcome is the smallest amount of apex cognition required to produce a correct, useful, executive-grade result.

Files

~/.claude/skills/jro-fable/
├── SKILL.md            # this file          ├── lib/
├── DELEGATION.md       # worker contracts    │   ├── pricing.json        # prices + tier bindings (SoT)
├── README.md           # install + overview  │   ├── pricing-check.sh    # drift detector
├── install.sh                                │   ├── log-receipt.sh      # one receipt
├── assets/                                   │   ├── receipts-digest.sh  # weekly + break-even warns
│   └── fable-orchestrator.excalidraw         │   └── bench.sh            # benchmark harness
├── data/receipts.jsonl # delegation log      └── benchmarks/tasks/*.txt # canonical prompts

Visual: assets/fable-orchestrator.excalidraw.

Changelog

• 26-0706: Added Worker Discipline Block to DELEGATION.md (paste-into-every-drone rules: tool-call budget, assume-and-continue, ≤30-word status, no future-work promises, no comment-scratchpad, injection hygiene for web-facing workers). Distilled from public system-prompt corpus (asgeirtj/system_prompts_leaks: ChatGPT agent mode, Gemini CLI, Cursor, Codex). Handoff packet now includes tool-call budget + discipline block.
• 26-0702: Fable 5 takes the JUDGMENT seat (redeployed 2026-07-01; the resolution rule now binds it). Added the subscription-vs-metered-API split (Fable free-in-plan for Claude Code judgment; Opus 4.8 stays the metered default with Fable as frontier escalation). EXECUTION seat upgraded Sonnet 4.6 → Sonnet 5 (near-Opus coding, intro $2/$10 through 26-0831, adaptive thinking default-on, own rate pool). New Effort Routing section: effort (low|high|xhigh|max) is the intra-model knob; downshift effort before downshifting model on judgment work; per-stage worker effort. Added Fable 5 API mechanics (always-on thinking, no prefill, refusal + server-side fallback beta, own smaller rate pool, 30-day retention), Opus 4.8 fast-mode row (2.5x speed, 2x price, credits-only, interactive-only), cache-over-model-hopping rule, and Opus→Fable escalation criteria. pricing.json re-verified against platform.claude.com 2026-07-02 (Opus 4/Sonnet 4 retired 26-0615; Opus 4.1 retires 26-0805). All facts from official Anthropic docs.