video youtu.be Watch ↗

Make Fable 5 80% Cheaper (& Other Usage Cheat Codes) — five levers for spending a premium model less

TL;DR

Chase AI, working against a stated constraint — a premium model (the source names Claude "Fable 5") is usage-capped on subscription plans and draws down the weekly limit fast, with a promo window closing — gives five levers to spend it less without losing what makes it good, and all five reduce to one idea: stop paying the top tier to do work a cheaper tier does about as well. (1) Drop the effort level — the highest-leverage move: on the DeepSWE agentic benchmark the source shows Fable at low scoring 60% at $3.76/task, beating Opus 4.8 at max (59% at $13), while Fable at max costs $22 for ~70% — so falling from max to low is an ~80% cost cut for ~10 points of pass rate, and a second Anthropic "FrontierCode" chart shows Fable-low matching Opus-4.8-max at half the cost; for non-complex work (e.g. web design) sit on low/medium. (2) Make the smart model the architect, cheap models the executors — have it plan, then dispatch each step to the appropriate model (Opus/Sonnet/GPT-5.5/local), or the low-ceremony version: plan mode → markdown plan → a fresh Opus session executes. (3) Bring in output-token-reduction skills like ponytail (claimed −54% LOC / −22% tokens / −20% cost at 100% safety; ~22% cheaper measured on Fable at medium) — "20% is a lot of money at scale, worth experimenting even if it looks suspect." (4) Invert the split for research — let cheaper models (Opus/Sonnet sub-agents in a deep-research fan-out; the source's run spawned 109) gather and adversarially vet web context, then hand it to the smart model to plan; never run the premium model as every sub-agent. (5) Advisor mode — set a cheap executor and /advisor the smart model, so the top tier is consulted only when the executor gets stuck (the source's SWE-bench Multilingual chart: Sonnet+Opus-advisor 74.8% @ $0.96 beats Sonnet-solo 72.1% @ $1.09 — better and cheaper). All model names, prices, benchmark figures, and dates are the source's claims, flagged for a later grounding pass, not adjudicated here.

Concepts introduced

Model-Tier Routing — new. Tips 2 & 4: split a task by role across model tiers — smart model does architecture/planning and dispatches execution to cheaper models (down), or cheap models research and hand context up to the smart model to plan.
Advisor Mode — new. Tip 5: the escalation-based instance of tier routing — a cheap executor consults a smart advisor only when stuck (/advisor), the set model being the executor.
Reasoning Effort Control — existing, corroborated. Tip 1: drop the effort dial (low/med/high/ x-high/max) to match task value; independent DeepSWE + FrontierCode numbers reinforce "low is the value pick."
Concise Prompting — existing, extended. Tip 3: the output-side companion — a skill (ponytail) that makes the model write leaner code, cutting cost as a side effect of "only what the task needs."

Held, not dropped

Themes the capture touches that do not warrant their own concept page yet (spin out on demand):

Fable 5 usage-cap economics — the weekly-limit / 50%-of-plan cap, "draws down usage faster than Opus 4.8," the "until July 7" window, usage-credit overflow, and the "kicked off Pro/Max, stuck paying API prices" framing. Time-bound, groundable; held as flagged claims, not a durable concept. (Overlaps the Fable-economics theme already held under How Anthropic Engineers Actually Prompt Fable 5 — six habits for a smarter, lighter touch.)
ultracode as an effort tier — the terminal shows an effort level above max labeled "x-high + workflows." A named, groundable product detail; held (noted on Reasoning Effort Control).
Codex-plugin cross-vendor delegation — /codex:rescue//codex:transfer to hand work to GPT-5.5 from inside Claude Code. A concrete routing mechanism; captured as a claim on Model-Tier Routing, held as a named tool rather than its own node.
GPT-5.5 as a cheap-capable "sleeper" outside model — recurring as a routing target and a benchmark baseline. Held as an attributed observation, not a concept.
Deep-research dynamic-workflow fan-out (109 sub-agents, baseline adversarial vetting) — the workflow substrate for tip 4; folded into Model-Tier Routing and linked to Workflows vs Agents / Agentic Workflow Patterns rather than spun out.
Sponsor segment ("Chase AI Plus" masterclass) — advertisement; not distilled.

Key claims

Dropping Fable 5's effort from max to low is an ~80% cost cut for a modest pass-rate loss: on DeepSWE the source shows low = 60% at $3.76/task beating Opus 4.8 max = 59% at $13, while max = $22 for ~70% (60→65→69→70% across low/med/high/x-high). observation — benchmark figures reproduced as the source's DeepSWE chart presents them; groundable, flagged for verification. → Reasoning Effort Control
Match the effort level to task complexity — sit on low/medium for non-complex work (e.g. web design), reserve high/x-high/max for genuinely hard tasks. (best practice) — context: cost-sensitive use of a usage-capped premium model; the "best" level is contingent on task difficulty, not a fixed default. → Reasoning Effort Control
On Anthropic's FrontierCode accuracy-vs-cost chart, Fable 5 at low (~$5, ~11%) matches Opus 4.8 at max (~$11, same score) — "same pass rate at half the cost" — and Fable at medium beats Opus 4.8 while cheaper than x-high. observation — a second benchmark reproduced as presented; not adjudicated here. → Reasoning Effort Control
Make the smart model the architect: have it plan, then dispatch each step to the appropriate (cheaper) model — Opus, Sonnet, GPT-5.5, or local — rather than plan and execute everything itself. (best practice) — context: multi-step work with varying step complexity; the routing pays off only when steps genuinely differ in required capability. → Model-Tier Routing
The low-ceremony split needs no orchestration: plan mode → a markdown plan → a fresh session on a cheaper model executes it, so the premium model doesn't burn tokens on low-level implementation. (best practice) — context: operators avoiding sub-agent wiring; trades automation for simplicity. → Model-Tier Routing
Invert the split for research: let cheaper models gather and adversarially vet web context (the model's knowledge cutoff isn't current), then hand it to the smart model to plan; don't run the premium model as every sub-agent in a fan-out. (best practice) — context: deep-research dynamic workflows (the source's run spawned 109 sub-agents); using the top model for all of them exhausts usage for no gain. → Model-Tier Routing
Output-token-reduction skills cut cost by making the model write leaner code — the source's ponytail claims −54% LOC / −22% tokens / −20% cost / 100% safe, and measured ~22% cheaper on Fable at medium — on the rule "write only what the task needs, never cut validation/security/accessibility." observation — the skill's own benchmark numbers reproduced as presented; a terse reasoning model may spend thinking tokens and go the other way, so the saving is contingent. → Concise Prompting
A ~20% cost reduction is worth experimenting with even if the mechanism looks suspect, because at thousands of dollars of spend it's real money. (best practice) — context: operating an expensive model at scale; a heuristic for when to try low-confidence savings, not a durable law. → Concise Prompting
Advisor mode consults the smart model only when the cheap executor gets stuck; the set model is the executor, so to make the top model the advisor you set your model to the executor and /advisor <top>. (best practice) — context: this harness's advisor UX (commands are version-specific); the role assignment (set-model = executor) is the load-bearing part. → Advisor Mode
Advisor mode can beat the cheap model solo on both score and cost: the source's SWE-bench Multilingual chart shows Sonnet 4.6 High + Opus advisor = 74.8% at $0.96 vs Sonnet solo = 72.1% at $1.09; the Fable-as-advisor case is extrapolated, not measured. observation — Anthropic "advisor strategy" figures reproduced as presented; the source is explicit no Fable-advisor numbers exist. → Advisor Mode
Fable 5 is usage-capped on subscription plans (source: "up to 50% of your plan's weekly usage limit … until July 7 … draws down usage faster than Opus 4.8"), with usage-credit overflow. observation — time-bound, groundable access/pricing claim; flagged for verification, not adjudicated. → held

Why this is novel (and corroborates Reasoning Effort Control + Concise Prompting)

The dominant stance is novel: the video's net-new contribution to the graph is the model-tier routing pattern and its productized escalation form, advisor mode — neither had a page. Tips 2, 4, and 5 are three faces of the same idea (put the expensive tier on the high-leverage cognitive role, cheap tiers on bulk work), which is why they spin out as Model-Tier Routing with Advisor Mode as its pull-when-stuck child, rather than three thin nodes.

The secondary stance is corroborates: tip 1 is an independent convergence on Reasoning Effort Control — a different benchmark (DeepSWE) reaching the same "cut effort to cut cost; low is the value pick, max barely beats x-high" conclusion the existing page already recorded from the FrontierCode chart in How Anthropic Engineers Actually Prompt Fable 5 — six habits for a smarter, lighter touch. Two sources now agree, so the concept is reinforced with fresh numbers, not duplicated. Tip 3 builds on Concise Prompting: it is the output side (make the model write leaner code via a skill) of the same "lighter touch for a capable model" thesis the existing page covers on the input side — appended as a claim, not a new node.

Faithfulness note: this source presents "Fable 5," "Opus 4.8," "GPT-5.5," "Sonnet 4.6," "Mythos 5," the prices, the usage-cap dates, and every benchmark figure (DeepSWE, FrontierCode, SWE-bench Multilingual, ponytail) as established fact. Per the distiller's lane these are recorded as the source's claims and flagged for a later grounding pass — not judged true/false, current/stale, or real/fictional here (this headless call has no external ground truth; a stale prior on a post-cutoff fact is exactly how a confident error would enter the vault). No in-vault concept contradicts these claims, so there is no contradicts tension to surface — only corroboration of the two existing effort/brevity concepts.

Illustrated walkthrough

Video is 12:01; visual coverage is "ok" (39/47 frames kept, 17% deduped, largest un-illustrated gap ~63 s). Absence of a sampled frame in a gap is not evidence of a static screen — slide/terminal changes on solid backgrounds can be missed. The deck alternates between live browser tabs (benchmark sites) and a Claude Code terminal.

t=00:00 (f0001–f0010) — talking-head intro. The hook: "reduce Fable 5's cost by 80% while still beating Opus 4.8" is one of five tricks for "reducing Fable 5's usage and token cost without losing what makes this model great." Stated framing: "a few days left until Fable 5 is kicked off the Pro and the Max plan and we're stuck paying API prices … we're also usage capped."
t=02:36 / 03:21 (f0011 / f0015) — DeepSWE benchmark (deepswe.datacurve.ai, "DeepSWE score", 113 tasks, updated July 1 2026). A cost-vs-accuracy curve, x-axis Avg cost per task running high→low left→right. On screen: claude-fable-5 [high] (Default) marked at ~$9.18 / 69%; the fable curve stays ~70% from ~$22 down to ~$3.76, then falls; claude-opus-4.8 [high] sits lower (~59% at its top, ~$13); gpt-5.5 [medium] in green. Narration ties numbers to effort levels: max $22 (~70%), low 60% at $3.76 — beating Opus 4.8 max (59%, $13), medium 65%, high 69%, x-high 70%. "More than an 80% reduction in cost … you could argue that's crazier than the jump from 59 to 70." DeepSWE is described as "long horizon, long running agentic tasks."
t=02:36 (f0014) — Anthropic FrontierCode chart (anthropic.com/news/claude-fable-5-mythos-5, "Accuracy vs Cost", mean cost/task on a log scale). Three series — Claude Fable 5 (orange), Claude Opus 4.8 (green), GPT-5.5 (grey dashed). Fable climbs low ~11% (~$5) → med ~18% → high 24% → xhigh 29.5% → max 31% (~$19); Opus 4.8 tops out ~13% at its xhigh/max (~$8–11); GPT-5.5 flat ~5%. Caption: "Diamond subset comprises the hardest 50 of 150 tasks." Narration: "same pass rate as Opus 4.8 on max at half the cost … at medium I'm blowing Opus 4.8 out of the water while still cheaper than x-high." Takeaway: "the less complicated the task — web design — you probably should be on medium or low." Change effort via /effort in the terminal.
t=04:00 (f0016–f0018) — sponsor (SponsorBlock-skipped 245–273 s; frames near the boundary show a self-promo for "Chase AI Plus"). Not distilled.
t=05:19 (f0020) — Codex plugin for Claude Code (github.com/openai/codex-plugin-cc). README: "Use Codex from inside Claude Code for code reviews or to delegate tasks to Codex." Commands shown: /codex:review, /codex:adversarial-review, /codex:rescue, /codex:transfer, /codex:status, /codex:result, /codex:cancel. This illustrates tip 2: the smart model plans, then dispatches parts to other models/vendors — "for the first part I want Opus, second part Sonnet, third part send to OpenAI/GPT-5.5." Low-ceremony alternative: plan mode → a markdown plan → "spin up another session with Opus and have it execute the plan Fable laid out … that stops Fable from burning tokens on low-level tasks."
t=06:39 (f0027) — ponytail README benchmark (github.com/DietrichGebert/ponytail). A bar chart and a "vs no-skill baseline" table: ponytail −54% LOC, −22% tokens, −20% cost, −27% time, 100% safe; caveman (terse-prose control) −20% LOC but +7% tokens, +3% cost, 100% safe; "YAGNI + one-liners" −33% LOC, −14% tokens, −21% cost, 95% safe (dropped a guard once). Prose: "ponytail is the only arm that cuts every metric and stays fully safe … The rule was never 'fewest tokens.' It is: write only what the task needs, and never cut validation, error handling, security, or accessibility. The code ends up small because it is necessary, not golfed … a terse reasoning model that spends thinking tokens deliberating the rungs can go the other way (on GPT-5.5 it does)." Narration: benchmarks were only tested on Haiku 4.5, so the presenter re-ran on Fable at medium → "essentially 22% cheaper, even better than what they claim for Haiku." Framing: "this is an expensive model; if there's a 20% boost, it's worth experimenting with even if it seems suspect."
t=07:40 (f0031) — Claude Code terminal, /effort selector. Header: "Claude Code v2.1.199 · Fable 5 with low effort · Claude Max." Banner: "Fable 5 is back. Until July 7, you can use up to 50% of your plan's weekly usage limit on Fable 5. If you hit your limit, you can continue on Fable 5 with usage credits. Fable 5 draws down usage faster than Opus 4.8." The Effort slider runs Faster → Smarter: low · medium · high · xhigh · max · ultracode, with ultracode labeled "xhigh + workflows." (This anchors tip 4's "dynamic workflows / ultracode" reference.)
t=08:21 (f0035) — Anthropic "advisor strategy" blog (claude.com/blog/the-advisor-strategy, "SWE-bench Multilingual"). Two points, y = Score %, x = Cost per agentic task ($) with the arrow pointing to cheaper: Sonnet 4.6 High + Opus advisor = 74.8% at $0.96 (upper-left) vs Sonnet 4.6 High solo = 72.1% at $1.09 (lower-right) — "a Sonnet that performed better for cheaper." Narration on tip 5: advisor mode = a smart advisor/planner hands its plan to a lower-level executor that reads/writes/runs tools, and "anytime it gets stuck, it shares its context with the adviser." Anthropic hasn't published Fable-as-advisor numbers, so that case is "a few assumptions" from this Opus/Sonnet graph. Mechanics: the set model is the executor, so to make Fable the advisor with Opus executing, set model to opus, then /advisor fable.
t=11:33 (f0039) — outro. "Five quick tips for reducing your Fable 5 usage while still getting the most out of this amazing model." Aside to Anthropic: keep it on Pro/Max and "give us more than 50% of the weekly limit."