Claude Fable 5 in Claude Code: A Setup That Doesn't Burn Your Quota

Claude Fable 5 is the flagship of the Claude 5 family, with 1M-token context via fable[1m]. It's the smartest model you can put in Claude Code right now — and also the one with the tightest quota. This post is the setup we landed on after hitting that quota wall once: what to configure, and the reasoning behind each piece, so you can adjust it for your own workflow.

If you just want the configuration, here it is:

Global settings: "model": "fable[1m]"
Subagent model: "env": {"CLAUDE_CODE_SUBAGENT_MODEL": "claude-sonnet-5"}
Auto-compact gate: autoCompactWindow = 400000
Check /mcp and disable servers you don't use
/clear between tasks, /compact during long ones
Fable does judgment, architecture, delegation, review — nothing else

The rest of the post explains why.

Your Usage Has Two Pools

Run /usage and you'll see two lines, not one: a weekly quota for all models combined, and a separate, smaller weekly quota just for Fable. They drain independently. In practice you can sit at 50% overall while Fable is already at 74%.

At official API pricing, Fable 5 costs roughly 2× Opus 4.8. Combined with the separate pool, the conclusion writes itself: every Fable token should go to work that only Fable can do.

The first lesson for new users: don't treat Fable 5 as the default do-everything worker. Treat it as the professor — or the chief architect. Quota is finite; spend it where it counts.

How We Hit the Wall

The trigger was a real incident. We asked Claude Code to verify about 100 CSV records — web search plus deep verification on each. It spun up multiple subagents to parallelize, and usage jumped to 95% of the weekly quota almost instantly.

That was the first time a weekly quota limit actually stopped our work. Afterward we did the sensible thing: asked Claude Code itself to design a subagent configuration that wouldn't do that again.

Split the Models: Fable Talks, Cheaper Models Work

The core strategy is that Fable 5 handles planning and orchestration, not every grunt task. Two patterns work: Advisor–Executor (Fable advises, you drive a cheaper session) or Orchestrator–Subagents (Fable orchestrates, subagents execute).

In Claude Code, the orchestrator pattern is two lines of settings:

"model": "fable[1m]",
"env": { "CLAUDE_CODE_SUBAGENT_MODEL": "claude-sonnet-5" }

The main conversation runs on Fable 5 with 1M context. Every subagent it dispatches runs on Sonnet 5 (or point it at Opus 4.8 if your executor work is harder).

The division of labor:

• Fable 5: understand the requirement, design the approach, dispatch work, review results, synthesize conclusions.
• Sonnet 5 / Opus 4.8: write the code, run the searches, drive the browser, collect the evidence.

When we tested this split, Fable-plans-Sonnet-executes reached about 94% of the accuracy of Fable doing everything itself (86% vs 91% on our verification benchmark) at a significantly lower cost. The takeaway isn't "downgrade blindly" — it's "let Fable design the division of labor first, then let lighter models execute it."

Context Is the Biggest Hidden Cost

Our /usage breakdown showed 74% of consumption happening in sessions that had grown past 150k tokens of context. The longer a session runs, the more every subsequent turn costs, because the whole context rides along on each request. Prompt caching softens this; it doesn't eliminate it.

Three habits, in priority order:

1. /clear when you switch tasks. The new task doesn't need the old task's memory.
2. /compact mid-way through long tasks. Same task, slimmer context.
3. Set an auto-compact gate: autoCompactWindow: 400000.

Why 400k? Without the setting, a 1M-context model doesn't trigger compaction until roughly 830k tokens. With it, compaction kicks in around 330k — long before the conversation balloons into luxury-priced territory.

Three More Places Quota Quietly Leaks

MCP results stay in context. Every large tool result becomes part of the conversation and gets paid for again on every subsequent turn. Disable MCP servers you don't use (check /mcp), and /compact after big queries.

Long-running and background sessions should be deliberate. Background loops and scheduled tasks are convenient, but "set and forget" has a token bill attached. Periodically list what's still running and stop what you no longer need.

Dispatch subagents with restraint. Each subagent is an independent session making its own rounds of requests. A simple single-file lookup belongs in the main conversation; fan out to subagents only when the work genuinely spans the codebase — full-repo scans, multi-location comparisons, parallel verification.

The Mental Model

One sentence version: Fable 5 is the most expensive judgment you can buy, so buy judgment with it — architecture, delegation, review — and buy everything else with models that cost a fraction as much.