Quick Answer
Prompting changed with Fable 5.1: adaptive reasoning is always on, so there is no extended-thinking toggle to flip anymore. Your primary control is now the effort level — LOW, MEDIUM, HIGH, XHIGH, or MAX. Anthropic's official guidance: start at the default (High) and test lower and higher levels against your own evals rather than guessing. Everything else — clear instructions, stable cacheable prefixes, steering instead of forcing tool calls — matters as much as it did on Fable 5, and now pays off twice via the $0.25/M cache read.
The Five Effort 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, where minutes and dollars are worth it |
The defaults are the tell: Anthropic picked High for the API and Claude Code (work you're paying per token for) and Medium for claude.ai and Claude Cowork (interactive chat, where speed matters). Effort can be changed mid-conversation — raise it when a step gets hard, drop it once the plan is set.
The Official Guidance: Start High, Then Measure
Anthropic's Fable 5.1 prompting docs are unusually direct: effort is the primary control, default to High, and test low/medium/xhigh/max against your own evals. Not against vibes — against a task set where you can score correctness. The reason: 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.
Practical loop:
- Build a 20–50 case eval for your task (even a spreadsheet of pass/fail).
- Run it at HIGH as the 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: A Decision Rule
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, well-templated edits, chat answers a human reviews anyway.
- HIGH when errors compound: anything that lands in production code, agent steps whose output feeds the next step, decisions you won't re-check.
The cost math sharpens this. Output tokens bill at $50/M, and higher effort burns more of them on reasoning. A session doing 10 hard steps at MAX might spend 60K thinking tokens ($3.00) where HIGH spends 15K ($0.75) — and MAX is worth it only if even one of those steps would otherwise fail in a way that costs you an hour. Full worked tables: Fable 5.1 pricing.
Rule of thumb: default HIGH, drop to MEDIUM for high-volume low-stakes calls, and promote individual hard steps to XHIGH/MAX mid-conversation rather than running a whole session hot.
Agent Patterns for 5.1
1. Stable, cacheable prefixes — the pattern that pays. Cache reads cost $0.25/M vs $10/M fresh input (the 75% cut that drives 5.1's cost savings). Structure agents so the giant stable part — system prompt, tool definitions, style guides — sits at the front and never changes, then vary only the trailing context. Claude Code's session pattern (big stable system prompt re-read every step) is exactly why its sessions get dramatically cheaper on 5.1.
2. Steer tool calls, don't force them. Fable 5.1 removed forced tool use — tool_choice {"type": "any"} or {"type": "tool"} now returns a 400. 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.
Adaptive reasoning makes this steering 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 conversation 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 better prompting: the failure context improves the next attempt.
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 pattern applies to Fable-vs-Astra routing choices — see the multi-agent patterns in GPT-6 Astra multi-agent guide for the orchestration side, and the Fable 5.1 vs GPT-6 Astra comparison for when to route where.
5. Migrating prompts from Fable 5? Thinking-toggle hacks and thinking-block pass-throughs need rework. Checklist: Fable 5.1 migration guide.
Example Prompts
Low-stakes extraction at LOW effort:
Extract invoice number, date, and total from this text. Output JSON only.
Hard debugging at XHIGH:
Our p99 latency tripled after the v2 deploy but CPU is flat. Here are the flame graphs and the diff. Find the most likely cause and rank your top three hypotheses with the evidence for and against each.
Tool steering with auto tool choice:
Use the run_tests tool before proposing any fix. Only propose a fix that makes at least the previously-failing tests pass without breaking others.
FAQ
What are the Fable 5.1 effort levels?
LOW, MEDIUM, HIGH, XHIGH, and MAX. Default is High on the API and in Claude Code, Medium on claude.ai and Claude Cowork. Effort can be changed mid-conversation.
Do I still need to enable extended thinking on Fable 5.1?
No. Adaptive reasoning is always on — there's no toggle. The effort level replaces it as the primary control over how much the model thinks.
Should I use medium or high effort?
Default High for anything where errors compound (production code, agent chains). Use Medium for high-volume, easily-reviewed tasks. Test both against your own evals per Anthropic's official guidance — the break-even depends on what a wrong answer costs you.
Does higher effort cost more?
Yes — reasoning consumes output tokens, billed at $50/M. MAX sessions can spend several times more on thinking than HIGH. Spend MAX on the rare genuinely hard step, not whole sessions.
Why do my forced tool calls fail with a 400?
Fable 5.1 removed tool_choice types any and tool. Switch to {"type": "auto"} and steer with instructions in the prompt.
How do I get the cheapest Fable 5.1 responses?
Combine all three: effort matched to task difficulty, a stable cacheable prefix so repeats bill at $0.25/M, and append-only history. Through a gateway like TeamoRouter you keep official rates and can switch models or effort per request.
Summary
Fable 5.1 prompting in one line: thinking is always on; effort is your dial; caching is your discount. Start at High, measure lower and higher levels against real evals, cache the stable prefix, steer tools with words instead of tool_choice, and append history instead of rewriting it. Try these patterns on TeamoRouter — pay-as-you-go, one key for Fable 5.1 and every other flagship.
Get Started
TeamoRouter — one key, base_url https://api.teamorouter.com/v1, Fable 5.1 with Alipay/WeChat billing.