How to Use Claude Fable 5 Effort Levels: Low, Medium, High, and Max
Claude Fable 5 has five thinking modes. Learn when to use low vs max effort, why overkill hurts performance, and how to match effort to task complexity.
What Effort Levels Actually Do in Claude Fable 5
Claude Fable 5 introduced something that earlier models handled behind the scenes: explicit control over how hard the model thinks before it answers. Instead of a single reasoning mode, you now choose from five thinking levels — off, low, medium, high, and max — and that choice directly affects output quality, cost, and latency.
Getting this right matters more than most people realize. Using too little effort on a complex problem gives you shallow answers. Using too much on a simple task wastes tokens, slows things down, and can actually introduce errors. The sweet spot is matching the effort level to the actual complexity of the task.
This guide explains each Claude effort level, what’s happening under the hood, and when to use each one.
The Five Effort Levels, Explained
Claude Fable 5’s effort system is built on extended thinking — a process where the model works through a problem internally before generating its final response. The effort level you set controls how large that internal reasoning budget is.
Here’s how the five levels break down:
Off (No Extended Thinking)
At this level, Claude responds without any internal chain-of-thought reasoning. It’s fast, cheap, and appropriate for tasks where the answer is direct.
This is the right choice for:
- Rephrasing or reformatting text
- Answering basic factual questions
- Simple classification tasks
- Extracting structured data from a clean input
- Real-time interactions where latency matters
- ✕a coding agent
- ✕no-code
- ✕vibe coding
- ✕a faster Cursor
The one that tells the coding agents what to build.
If you’re building a chatbot that handles things like “what are your business hours?” or “summarize this paragraph,” you don’t need extended thinking. Off mode handles it cleanly.
Low Effort
Low effort activates a small thinking budget — enough for Claude to work through a step or two before responding. It adds a modest reasoning layer without much cost or latency impact.
This is useful for:
- Answering questions that require light inference (but not deep reasoning)
- Short writing tasks with mild complexity (e.g., drafting an email reply)
- Basic comparisons between two options
- Tasks with some ambiguity that needs light disambiguation
Think of low effort as the baseline for anything that isn’t purely mechanical. It catches obvious logical errors and adds a small layer of self-checking.
Medium Effort
Medium effort is the most broadly applicable setting. It gives Claude a meaningful reasoning budget — enough to think through multi-step problems, consider edge cases, and check its own logic.
This handles:
- Moderately complex analysis
- Writing tasks with structure and nuance (reports, proposals, breakdowns)
- Code that solves a specific, well-defined problem
- Multi-criteria decision support
- Summarization where accuracy and completeness both matter
If you’re unsure which level to use and you don’t have a specific reason to go higher or lower, medium is usually the right default.
High Effort
High effort allocates a substantially larger reasoning budget. Claude can work through complex, multi-layered problems, consider competing hypotheses, and recover from early errors in its own reasoning.
This is the right level for:
- Difficult coding problems (debugging, algorithm design, architecture review)
- In-depth research synthesis across multiple concepts
- Legal, medical, or technical analysis where accuracy is high-stakes
- Evaluating arguments with multiple interdependencies
- Long-form content where consistency and logical structure matter throughout
High effort significantly increases token usage and latency. Use it when the output quality justifies both costs.
Max Effort
Max effort is the ceiling — the largest thinking budget the model supports. Claude will reason extensively, often revisiting earlier conclusions, exploring multiple solution paths, and double-checking its work before responding.
Max effort is appropriate for:
- The hardest reasoning tasks: complex proofs, multi-step optimization, hard competitive programming problems
- High-stakes decisions where errors are costly
- Tasks with many interacting constraints
- Novel problem types where standard approaches might fail
This is the tool for edge cases, not everyday work. The latency can be significant, and it costs considerably more per call. Most tasks don’t need it.
Why More Thinking Isn’t Always Better
This is the counterintuitive part: cranking effort to max on every task doesn’t improve quality — it often hurts it.
Here’s why that happens:
Overthinking simple tasks introduces noise. When you give Claude a large reasoning budget for a trivial request, it sometimes invents complexity that isn’t there. It starts second-guessing correct answers, considering irrelevant edge cases, and producing outputs that are longer and less useful than a direct response would have been.
High effort on mismatched tasks wastes context. Extended thinking consumes tokens from the model’s context window. On a simple task, those tokens are gone without contributing to output quality.
Remy doesn't write the code. It manages the agents who do.
Remy runs the project. The specialists do the work. You work with the PM, not the implementers.
Latency compounds in workflows. If you’re running a multi-step automation and every step uses max effort, the cumulative latency adds up fast — even when most steps don’t need it.
The practical rule: match the effort to the cognitive demand of the task, not to your anxiety about getting the right answer.
A Framework for Choosing the Right Effort Level
Rather than guessing, you can use a few questions to pick the right level:
1. How many logical steps does this require?
- One or two steps → Off or Low
- Three to five steps → Medium
- More than five, or interdependent steps → High or Max
2. What happens if the answer is wrong?
- Low stakes, easily corrected → Off or Low
- Medium stakes → Medium or High
- High stakes, costly to fix → High or Max
3. Is there a clear “right answer,” or does this require judgment?
- Clear factual answer → Off or Low
- Requires inference but has a definable best answer → Medium
- Genuinely ambiguous or requires weighing many factors → High
4. How fast does this need to be?
- Real-time or near-real-time → Off or Low
- Latency-tolerant → Any level
- Asynchronous background processing → High or Max is fine
Run through these quickly before assigning an effort level, and you’ll get close to optimal on most tasks.
Practical Examples by Use Case
Sometimes it’s easier to see the right choice in context:
Customer support chatbot Use Off or Low. Responses need to be fast, queries are mostly simple, and extended thinking adds cost without meaningful quality improvement.
Document summarization pipeline Use Medium. You want coherent, accurate summaries without paying for max-level reasoning on routine content.
Code review agent Use High. You’re asking Claude to identify logic errors, security issues, and structural problems — tasks that genuinely benefit from careful reasoning.
Competitive math or logic puzzles Use Max. These are exactly the problems extended thinking was designed for.
Email drafting assistant Use Low or Medium, depending on the complexity of the email. A quick reply to a scheduling request is Low. A nuanced negotiation email is Medium.
Research synthesis agent Use High. You’re pulling together complex information and want the model to reason carefully across sources before writing conclusions.
Common Mistakes When Setting Effort Levels
Defaulting to Max “just to be safe” This is the most frequent mistake. It costs more, runs slower, and produces worse results on simple tasks. Reserve Max for genuinely hard problems.
Using Off for anything requiring inference Off mode skips extended thinking entirely. If the task has even mild logical complexity, Off mode will miss things.
Not adjusting effort across workflow steps Different steps in a workflow have different complexity levels. A retrieval step might need Low; an analysis step might need High. Applying one setting across all steps is inefficient.
Confusing prompt length with task complexity A long, detailed prompt doesn’t necessarily need high effort. A short, hard question might need Max. Effort should track cognitive demand, not input length.
Ignoring cost in iteration When prototyping, using High or Max effort in every test run burns budget fast. Build with Low or Medium, then dial up for final testing.
Built like a system. Not vibe-coded.
Remy manages the project — every layer architected, not stitched together at the last second.
How MindStudio Lets You Control Effort Levels in Real Workflows
If you’re building agents and automations that use Claude Fable 5, effort level configuration is a practical decision you’ll make repeatedly — and getting it right affects both the quality and cost of your deployed workflows.
MindStudio gives you direct control over Claude’s effort settings within its visual workflow builder. When you add a Claude step to a workflow, you can configure the thinking level for that specific step rather than applying a blanket setting across everything.
This matters for multi-step workflows. A workflow that pulls data, analyzes it, generates a report, and sends an email might look like this in practice:
- Retrieval step: Off (fast, no reasoning needed)
- Analysis step: High (this is where thinking matters)
- Summary generation: Medium (coherent writing, not high-stakes)
- Email formatting: Low (template with light personalization)
Setting the right effort per step — rather than running everything at one level — keeps workflows fast and cost-efficient without sacrificing quality on the steps that need it.
MindStudio supports 200+ models out of the box, including the full Claude lineup, with no separate API keys required. You can swap between models and effort levels, compare outputs, and fine-tune prompts without leaving the builder. If you want to explore Claude Fable 5’s extended thinking in a real workflow, you can try MindStudio free at mindstudio.ai.
For more on building Claude-based workflows, see the guide to building AI agents with no code on MindStudio or explore how prompt engineering works in multi-step automations.
FAQ
What is the default effort level in Claude Fable 5?
The default depends on the API configuration and client you’re using. In most implementations, Claude defaults to Off or a low thinking budget when no explicit effort level is set. If you’re using Claude through a platform like MindStudio or the Anthropic API directly, you’ll want to set the level explicitly rather than relying on defaults.
Does higher effort always produce better outputs?
No. Higher effort produces better outputs on tasks that require extended reasoning — complex problems, multi-step logic, ambiguous decisions. On simple, direct tasks, higher effort often produces worse outputs because the model overthinks straightforward requests, introduces unnecessary caveats, or second-guesses correct answers. Match the effort to the task’s actual complexity.
How much does effort level affect cost?
Significantly. Extended thinking tokens are billed separately from input and output tokens in Anthropic’s pricing model. Max effort can cost several times more than Off or Low for the same prompt. For high-volume use cases, effort level selection is one of the most impactful cost levers available.
Can I change the effort level mid-conversation?
Yes, in most API implementations you can set a different thinking budget for each individual request in a conversation. This lets you use low effort for back-and-forth messages and bump up to high or max only when the user asks something that requires deep reasoning.
What’s the difference between High and Max effort in practice?
Plans first. Then code.
Remy writes the spec, manages the build, and ships the app.
High effort gives Claude a large reasoning budget — enough to handle most complex tasks well. Max effort extends that budget to the model’s ceiling, which is most useful for problems where High occasionally fails: extremely difficult logic puzzles, competitive programming, complex multi-constraint optimization. For the majority of real-world use cases, High is sufficient and noticeably cheaper than Max.
Is effort level the same as temperature?
No, these are different controls. Temperature affects how deterministic or creative the model’s outputs are — higher temperature means more variation. Effort level controls the depth of reasoning before the final response is generated. You can set both independently. For precise analytical tasks, you’d typically want low temperature and higher effort.
Key Takeaways
- Claude Fable 5 has five effort levels: Off, Low, Medium, High, and Max — each allocating a different internal reasoning budget before responding.
- Off and Low are best for fast, simple tasks where extended reasoning adds no value.
- Medium handles most everyday use cases: analysis, writing, structured tasks.
- High and Max are reserved for genuinely complex problems where careful reasoning matters and cost/latency tradeoffs are acceptable.
- Overkill effort on simple tasks produces worse outputs, not better ones.
- In multi-step workflows, assigning effort per step — rather than applying one level to everything — keeps costs down and quality consistent.
The best way to develop intuition for effort levels is to experiment. Build a test set of your most common task types, run them at different effort levels, and compare outputs. The patterns become obvious quickly, and the cost savings from getting this right can be substantial at scale.
