Every Claude prompting habit I'd built assumed one thing: thinking is something you turn on. You toggle extended thinking, you budget thinking tokens, you work around the toggle in your agent framework. Claude Fable 5.1 — Anthropic's September 1 flagship — deleted that mental model. Adaptive reasoning is always on. There is no toggle.
What you get instead is a dial: the effort level. And learning to turn it well is now the difference between a $0.75 session and a $3.00 session that produces the same output.
The five levels
| Effort | Reasoning depth | Cost / latency | Default on | Good for |
|---|---|---|---|---|
| LOW | Minimal thinking | Cheapest, fastest | — | Extraction, formatting, simple rewrites |
| MEDIUM | Moderate | Low | claude.ai, Claude Cowork | Routine Q&A, short code edits |
| HIGH | Full adaptive reasoning | Moderate | API, Claude Code | Default for most dev work |
| XHIGH | Extended | High | — | Hard debugging, architecture, multi-step math |
| MAX | Maximum budget | Highest | — | Research-grade problems |
The defaults are the tell. Anthropic picked High for the API and Claude Code — work you pay for per token — and Medium for claude.ai and Cowork, where speed matters more. And unlike a system prompt, effort can be changed mid-conversation: raise it when a step gets hard, drop it once the plan is set.
The official guidance is unusually direct
Anthropic's Fable 5.1 prompting docs say: effort is the primary control, default to High, and test the other levels against your own evals — not against vibes. The reasoning: adaptive reasoning means the model already decides how much to think within an effort level, so the lever you're turning is a budget ceiling, and the right ceiling is workload-specific.
A practical loop that takes an afternoon:
- Build a 20–50 case eval for your task (a spreadsheet of pass/fail qualifies).
- Run it at HIGH as baseline.
- Try MEDIUM and XHIGH. If MEDIUM matches at meaningfully lower cost, use it. If XHIGH fixes real failures, reserve it for those failure classes.
- Revisit quarterly — model updates shift the sweet spot.
Medium vs high: it's a question about your errors
The question isn't "which is smarter," it's what a wrong answer costs you.
- MEDIUM when errors are cheap to catch: internal drafts, summarization, boilerplate, chat answers a human reviews anyway.
- HIGH when errors compound: anything landing in production code, agent steps whose output feeds the next step, decisions you won't re-check.
The cost math sharpens it. Output bills at $50/M, and higher effort burns more output on reasoning. A session doing 10 hard steps at MAX might spend 60K thinking tokens ($3.00) where HIGH spends 15K ($0.75). MAX pays for itself exactly when even one of those steps would otherwise fail in a way that costs you an hour. The full worked tables are in Fable 5.1 pricing explained.
Rule of thumb: default HIGH, drop to MEDIUM for high-volume low-stakes calls, promote individual hard steps to XHIGH/MAX mid-conversation — rather than running a whole session hot.
Four agent patterns that changed with 5.1
1. Stable, cacheable prefixes — the pattern that pays. Cache reads cost $0.25/M vs $10/M fresh input. Structure agents so the giant stable part — system prompt, tool definitions, style guides — sits at the front and never changes; vary only the trailing context. Claude Code's session pattern (big stable prefix re-read every step) is exactly why its sessions get dramatically cheaper on 5.1.
2. Steer tool calls, don't force them. 5.1 removed forced tool use — tool_choice {"type": "any"} or {"type": "tool"} returns a 400 now. Use {"type": "auto"} and say what you want in prose:
Call the get_weather tool for Tokyo, then answer using only its result.
You must use the search_docs tool before answering; if it returns nothing, say so.
Counterintuitively, adaptive reasoning makes this more reliable than forcing was — the model can think about whether and how to call, instead of being locked into a call it can't reason about.
3. Append, don't rewrite history. Editing prior turns mid-conversation is restricted in 5.1, and its thinking blocks can't cross model generations. Agent loops should append corrective turns — "that approach failed because X, try Y" — instead of patching the transcript. It's also just better prompting.
4. Effort as an agent-loop throttle. In multi-agent systems, run planner and hard-reasoning steps at HIGH/XHIGH and per-item worker steps at MEDIUM/LOW. The same shape applies across vendors — Fable 5.1 vs GPT-6 Astra covers when to route a step to the other flagship entirely.
Migrating prompts from Fable 5? Thinking-toggle hacks and thinking-block pass-throughs need rework — the checklist is in the migration guide.
Fable 5.1 prompting in one line
Thinking is always on; effort is your dial; caching is your discount. Start at High, measure the other levels against real evals, cache the stable prefix, steer tools with words instead of tool_choice, and append history instead of rewriting it.
CTA: TeamoRouter is a multi-model API gateway — Claude Fable 5.1 and GPT-6 Astra are both available behind one key and one base URL, so you can test effort levels and compare models per task at official rates, pay-as-you-go, Alipay/WeChat supported.
Top comments (0)