Fable 5 Is in Your Max Plan Now. Included Isn't Unlimited.

The access chaos is over: Fable 5 is permanently included in Max and Team Premium—at 50% of a weekly limit every model shares. Quota is the currency again, and tokens-per-task is the only lever you own.

Six weeks of whiplash—release, export-control blackout, redeployment, three deadline extensions—ended quietly on July 20. Claude Fable 5 is now permanently included in Max, Team Premium, and Enterprise premium seats, at up to 50% of your weekly usage limits, at no extra cost. Pro and standard seats aren’t included: they run Fable 5 on usage credits at $10/M input, $50/M output, softened by a one-time $100 transition credit—roughly 2 million output tokens at published rates, or about one long autonomous coding session. Alongside it, Claude Code’s weekly limits got a +50% boost (through August 19, as of publication), and Fable 5 in Claude Code requires v2.1.170 or later.

The strongest coding model on the market now lives inside the subscription most engineering teams already pay for. That’s genuinely good news. It also has a catch worth reading twice.

The Catch: One Pool, Every Model

The help center’s phrasing is precise: you can use up to 50% of your weekly limit on Fable 5, but “your use of other models draws from the same usage limits.” The Fable allowance is not additive. Every Sonnet 5 session, every Opus 4.8 task, every Fable 5 run drains one shared weekly pool—Fable is simply capped at half of it. Hit the 50% mark and you choose: keep going on usage credits, or drop to another model. Hit the weekly ceiling and everything stops until reset.

So the settlement didn’t remove the meter. It moved it. For four weeks the constraint was dollars—metered credits, then per-engineer spend caps. Now, for Max and Team Premium, the constraint is back to where it started in June: quota. Dollars, caps, quota—three different meters in six weeks, and one thing stayed constant through all of them: the tokens your agent spends per task. That’s the only variable you actually control, and it’s the one nobody instruments.

What 50% of a Week Actually Buys

Think of the Fable slice as a fixed pot. Anthropic doesn’t publish it in tokens—your usage dashboard is the only reliable gauge—but whatever it is, it’s finite, weekly, and shared-adjacent: waste inside the Fable slice is waste, and waste outside it (Sonnet reading 20 files to change 4) shrinks the same ceiling the Fable slice lives under.

Where the tokens go is the part we can measure. 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 in the repo, rerunnable by anyone. 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.

~80% of the input tokens bought nothing. One representative task, not a universal guarantee—but the ratio is the point: cut context per task ~5× (4,764 ÷ 969 ≈ 4.9, illustrative, input tokens only) and the same 50% slice covers roughly five times the Fable 5 tasks per week. The engineer who used to burn the Fable allowance by Wednesday now finishes the week inside it—same model, same plan, same allowance.

The same arithmetic is sharper on Pro. The $100 transition credit is reported to cover roughly one long autonomous coding session at Fable rates. A session that loads five times less context stretches that same credit across roughly five times the work—illustratively, one week of runway becomes most of a month. The credit is fixed. The burn rate isn’t.

Included Is the New Battleground

Step back and the July 20 settlement is a preview of how frontier access will work everywhere: the best model is included, rationed by quota, with a paid overflow valve. OpenAI’s GPT-5.6 Sol undercuts Fable per-token ($5/$30); Anthropic answers not with a price cut but with bundling. Either way the invoice line disappears and the constraint becomes an allowance you can’t see until you hit it.

Which means the discipline that mattered under metering matters more under inclusion, not less. A meter at least showed you the waste in dollars. A quota shows you nothing until Wednesday afternoon when Fable 5 greys out mid-task and your team finishes the week on a smaller model. The teams that thrive under included-but-capped frontier access are the ones that treat context per task as an engineering metric—instrumented, benchmarked, driven down.

The Fix Is the Same as It Was in June

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 one 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—the 4 files, not the 20—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 model-agnostic: the same graph feeds Fable 5 inside its 50% slice, Sonnet 5 for bulk work, and whatever lands in the pool next quarter.

Quota in June, dollars in July, caps mid-month, quota again now. The meter keeps changing shape; the waste it measures doesn’t. An agent that reads the chain instead of the firehose beats every version of the meter—including the one that comes next. 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 the allowance instrumented properly. The benchmark is committed. Rerun it before Wednesday.