Fable 5 Goes Metered: Every Wasted Token Is Now a Line Item

On July 13, Claude Fable 5 switches from plan limits to usage credits at $10/$50 per million tokens. The habit that costs you most? Agents that read 20 files when 4 would do.

The best coding model you can rent is about to start charging by the token. Claude Fable 5—released June 9, pulled offline during a three-week export-control review, redeployed globally on July 1—currently comes included with Pro, Max, and Team plans, capped at 50% of your weekly usage limits. As of publication, that included window ends July 12. From July 13, Fable 5 bills through usage credits at API rates: $10 per million input tokens, $50 per million output—double Opus 4.8, and the most expensive model Anthropic has ever priced for general use. The credits are one pool, shared across Claude.ai and Claude Code.

So the question every team running Fable 5 in Claude Code faces this week isn’t “is it worth it?”—by most accounts it’s the strongest software-engineering model available. The question is: how much of what you’re paying for is work, and how much is your agent reading files it never needed?

We wrote three weeks ago that context bloat burns quota. With Fable 5, the same bloat burns dollars—at the highest per-token rate on the market.

Three Ways Fable 5 Punishes a Fat Context

The rate itself

$10 per million input tokens means every token your agent stuffs into context is billed at 2× Opus 4.8, 5× Sonnet 5’s introductory rate. The model didn’t get less efficient—your habits got more expensive. An agent that greps a term and reads every match was always wasteful; on Fable 5 the waste has a price tag with an extra zero.

The tokenizer tax

Fable 5 runs on Anthropic’s newer tokenizer (shared with Opus 4.7+), which can use up to 35% more tokens for the same text. The same file, the same prompt, the same pasted stack trace—more tokens than it cost you on older models, before the higher rate even applies. Rate × token inflation compounds: content you used to ship for $X of input can now cost well over 2X. Every redundant file read is taxed twice.

The 1M-context temptation

Fable 5’s context window is 1 million tokens by default—no opt-in beta, no long-context surcharge. That’s the trap. A million tokens fits most mid-sized repos, so the lazy integration is “dump everything in and let the model sort it out.” Do the arithmetic: one full-context request is $10 of input before the model writes a single token of output. Reporting on multi-turn agent sessions puts a naive ten-turn conversation—full context resubmitted each turn, no caching—at $100+ in input alone, versus roughly $21.50 with prompt caching (a ~$12.50 cache write, then ~$1 per million on reads). Caching helps a lot. But caching a bloated context is still paying to store and re-read noise. The cheapest token is the one you never load.

The Fix Isn’t a Cheaper Model. It’s a Smaller Context.

The standard advice circulating this week is model routing: reserve Fable 5 for planning and the hardest problems, push bulk coding to Sonnet 5 at a fifth of the rate. That’s sound advice—do it. But routing decides which meter you burn, not how much of it. An agent that reads 20 files to change 4 wastes 80% of its context on Sonnet exactly as it does on Fable. The multiplier changes; the leak doesn’t.

The leak is retrieval. Agents find code with keyword search or vector similarity—instruments that optimize for recall and return everything tangentially related. In code, the relationship that matters isn’t lexical similarity; it’s the dependency edge. OrderService.place_order() calls a repository, which uses a cache policy. Those files form a chain. No keyword search finds that chain; a dependency graph is that chain. (Full primer in the previous post.)

The Benchmark Math, at Fable 5 Rates

Coograph ships a committed benchmark—a single fixed task (“Add caching to OrderService.place_order()”) against a single committed fixture (bench/fixtures/sample-app/), both checked into the repo so anyone can rerun it. On that task:

• Naive grep + read all matches: 20 files, ~4,764 input tokens, 21 tool calls.
• Graph minimal-context query: 4 files, ~969 input tokens, 5 tool calls.

That’s ~80% fewer tokens and ~4× fewer tool calls on one representative refactoring task—one task, not a universal guarantee; savings scale with repo size and how focused the change is.

Now put Fable 5 prices on it. At $10 per million input tokens, this one small task costs roughly $0.048 of input via keyword retrieval versus $0.010 via the graph—illustrative arithmetic, and the benchmark’s token counts predate Fable’s tokenizer, so on Fable both sides inflate by up to ~35% while the ratio holds. Fractions of a cent on a small fixture. But the fixture is tiny and the mechanism is linear: scale the same 80% waste to a real repo where a task pulls in tens of thousands of context tokens, multiply by every task your team runs per week, and the gap is what decides whether Fable 5 is a rounding error or the biggest line on the tooling bill.

And until July 12, the same math runs against the clock instead of the card: Fable 5 draws from a 50%-of-weekly-limits allowance, so ~80% fewer tokens per task is directly more Fable tasks before the cap cuts you off mid-week.

What This Looks Like in Practice

Coograph is an open-source, MIT-licensed parser and graph engine. It parses your codebase with tree-sitter (Python, TypeScript, JavaScript, Go, Rust, Java, C#, Ruby, and more, with a regex fallback) into a single local SQLite file—.code-graph/graph.db—that never leaves your machine. Your agent queries it through MCP tools (get_minimal_context, query_graph) instead of grepping, and gets the dependency chain in one pass. A git hook re-parses only changed files per commit.

Setup is minutes: clone Coograph as a sibling directory, run /coograph-init from Claude Code (or Copilot, Cursor, Windsurf, Codex CLI, OpenCode, Aider, Cline), and build the graph. It’s a context layer, not an agent replacement—and it’s model-agnostic, which is exactly the point this month: whether a task routes to Fable 5, Opus 4.8, or Sonnet 5, the graph cuts what you feed it.

Fable 5 is worth the price—for the tokens that do work. The ones spent re-reading files your agent never needed were dead weight at plan-limit prices, and from July 13 they’re dead weight at $10 a million. Generate your first graph with the getting-started guide, see what’s inside it on the code-graph page, or talk to us about Coograph Pro if your team wants hands-on integration. The benchmark is committed. Rerun it yourself before the meter starts.