Claude Fable 5 Effort Levels Explained: When to Use Low, Medium, High, and Max
Claude Fable 5 has five effort levels that control cost and reasoning depth. Learn which to use for routine tasks vs complex agentic workflows.
What “Effort Levels” Actually Mean in Claude
When you call Claude through an API or a platform like MindStudio, you’re not just choosing a model — you’re also deciding how hard that model should think. Claude’s effort level setting controls the depth of reasoning applied to any given task, which directly affects response quality, latency, and cost.
With Claude Fable 5, Anthropic formalized this control into five distinct levels: none, low, medium, high, and max. Understanding which level to use — and when — can be the difference between a fast, cheap workflow and a slow, expensive one that still doesn’t give you the output you need.
This guide breaks down each effort level, explains what’s happening under the hood, and helps you match the right level to the right task. Whether you’re building a simple customer FAQ bot or a multi-step autonomous agent, the right effort configuration matters more than most builders realize.
The Five Effort Levels at a Glance
Before going deeper, here’s a quick overview of what each level means:
| Level | Thinking Budget | Best For |
|---|---|---|
| None | 0 tokens | Simple, fast, cost-sensitive tasks |
| Low | ~1,000–2,000 tokens | Lightly structured responses with minimal reasoning |
| Medium | ~4,000–8,000 tokens | Most standard business tasks |
| High | ~16,000–32,000 tokens | Complex multi-step problems |
| Max | ~32,000+ tokens | Hard reasoning, research, and agentic tasks |
These levels map to Claude’s extended thinking budget — a pool of “thinking tokens” the model can use before generating a final response. The larger the budget, the more Claude can reason through a problem before committing to an answer.
How Claude’s Extended Thinking Works
Claude’s extended thinking is Claude’s internal scratchpad. When you enable it, Claude generates an internal reasoning chain before producing its final output. This chain isn’t shown to end users by default — it’s invisible processing that improves the quality of the final answer.
Think of it like the difference between someone answering a math question off the top of their head versus taking a minute to work through it on paper. The latter is slower, but more accurate on hard problems.
The thinking budget is measured in tokens. Setting a higher budget lets Claude:
- Break down complex problems into sub-steps
- Reconsider and revise its own reasoning mid-process
- Check its work before finalizing an answer
- Handle ambiguous or multi-constraint problems more reliably
At lower effort levels, Claude still responds intelligently — it just doesn’t spend as long reasoning before answering. For simple tasks, that’s a feature, not a bug.
Breaking Down Each Effort Level
None: When Speed Beats Depth
At effort level none, extended thinking is disabled entirely. Claude responds from its trained knowledge and in-context information without any additional deliberative reasoning.
This is the right choice when:
- You’re doing text formatting, extraction, or transformation
- The task has a clear, deterministic answer
- Speed and cost are the primary constraints
- You’re running high-volume batch jobs where marginal quality improvement doesn’t justify the cost
Example use cases: Summarizing a single email, classifying a support ticket into a category, translating a sentence, formatting a JSON object.
The tradeoff is obvious — complex problems handled at effort level none will produce shallower responses. But for routine automation at scale, this level keeps costs manageable.
Low: A Little Reasoning Goes a Long Way
Low effort gives Claude a small thinking budget, typically in the range of 1,000–2,000 tokens. Claude will do light reasoning before responding — enough to organize a multi-part answer or handle mild ambiguity, but not enough for deep analysis.
This level works well when:
- The task has some structure but no real complexity
- You need slightly better output quality than none provides
- You’re processing medium-volume tasks and cost is still a concern
- The task benefits from a brief planning pass (e.g., writing a short structured response)
Example use cases: Drafting a short product description, generating a list of follow-up questions from a meeting transcript, writing a personalized email reply based on CRM data.
Low is often underused. Many builders jump straight from none to medium when low would cover most of the gap at a fraction of the cost.
Medium: The Default Workhorse
Medium is where most business automation should live. It provides a meaningful reasoning budget — roughly 4,000–8,000 tokens — that handles the majority of real-world tasks well.
At this level, Claude can:
- Work through multi-step instructions
- Handle tasks with several competing requirements
- Generate well-organized, coherent long-form content
- Apply consistent judgment across a structured workflow
This is appropriate for:
- Content generation (blog drafts, reports, proposals)
- Customer support responses that require context synthesis
- Document analysis with several questions to answer
- Any task where quality matters but the problem isn’t fundamentally hard
- ✕a coding agent
- ✕no-code
- ✕vibe coding
- ✕a faster Cursor
The one that tells the coding agents what to build.
Example use cases: Analyzing a 10-page contract for key clauses, writing a proposal based on a client brief, generating a detailed project plan from meeting notes.
For most MindStudio workflow steps, medium is the right default unless you have a specific reason to go higher or lower.
High: Complex Problems and Multi-Step Chains
High effort gives Claude a substantial thinking budget — typically 16,000–32,000 tokens. At this level, Claude can hold significantly more context in its reasoning chain, revisit assumptions, and work through problems that have multiple constraints or require genuine synthesis.
Use high when:
- You’re asking Claude to reason through genuinely difficult problems
- The task involves synthesizing large amounts of information
- Mistakes would be costly and accuracy is critical
- You’re building agentic workflows where Claude needs to plan before acting
Example use cases: Analyzing financial statements and generating investment commentary, reviewing a complex legal document, debugging a multi-system architecture problem, generating a detailed technical specification from vague requirements.
One practical consideration: high effort significantly increases latency. A task that returns in 3–5 seconds at medium might take 15–30 seconds at high. For synchronous, user-facing applications, that’s a real UX constraint. For background agents where the user isn’t waiting, it’s fine.
Max: When You Need Claude’s Best
Max is Claude’s full reasoning capacity — 32,000 or more thinking tokens. This is the setting for problems where accuracy matters most and you’re willing to pay for it in both cost and time.
Max is appropriate when:
- You’re solving hard reasoning problems (math, logic, code review, research synthesis)
- The task involves adversarial inputs where Claude needs to be robust
- You’re running a fully autonomous agent that needs to plan, execute, and recover from errors
- A wrong answer has downstream consequences that are expensive to correct
Example use cases: Generating and reviewing complex code with edge case handling, building a research brief from 50+ sources, autonomous task planning for multi-step agents, formal verification of business logic.
Don’t default to max just because you want the best output. On most tasks, high effort will get you 90–95% of max quality at a fraction of the cost. Reserve max for the small subset of tasks that genuinely need it.
Cost and Latency: The Real Tradeoffs
Effort levels aren’t free. The thinking tokens Claude uses count toward your total token usage, and they add latency to every response. Here’s a rough picture of the tradeoffs:
Cost scaling: Each step up in effort level roughly doubles the cost of a call. Going from none to max on a complex task could increase cost by 10–20x. For high-volume workflows, that compounds fast.
Latency scaling: Higher effort levels add thinking time before Claude generates its first output token. At max effort, a complex task might take 45–60 seconds to complete. That’s fine for a background agent, but it’s a poor experience if a user is waiting for a response in real time.
Quality curve: The quality gains from effort levels aren’t linear. The biggest jump is typically from none to low, and again from medium to high. Going from high to max produces smaller marginal improvements on most tasks, with a large cost increase.
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
The practical implication: profile your tasks before defaulting to high or max. Run the same prompt at medium and high, compare outputs, and decide whether the quality delta justifies the cost.
Matching Effort Levels to Workflow Types
Different workflow architectures need different effort configurations, and often the right answer is mixing levels within a single workflow.
Simple Automation Workflows
If your workflow is essentially “receive input → transform → output,” effort level none or low is almost always sufficient. These are deterministic pipelines that don’t require Claude to reason — they require Claude to execute.
Pattern: Email → Extract key fields → Format → Log to spreadsheet. None or low throughout.
Content Generation Pipelines
For workflows that generate substantive content — reports, proposals, analysis — medium is usually the floor, and you may want high for the core generation step while using low for supporting steps like formatting or extraction.
Pattern: Fetch data (none) → Summarize (low) → Generate report (medium or high) → Format output (none).
Agentic Workflows
This is where effort levels get interesting. Autonomous agents that plan, execute, and adapt need high or max for their planning and decision-making steps. But sub-tasks within an agent — like calling a tool, parsing an API response, or formatting a result — can often run at low or none.
Strategically layering effort levels across an agent’s steps is one of the most effective ways to control cost without sacrificing quality where it counts.
How MindStudio Handles Claude Effort Levels
If you’re building workflows on MindStudio, you can configure Claude’s effort level directly in the model settings for any workflow step. This gives you per-step control — meaning you can run a high-effort planning step followed by a low-effort formatting step in the same agent, without writing any code.
This matters because most real workflows don’t need maximum reasoning at every step. A well-structured MindStudio workflow might look like:
- Step 1 — Parse incoming data → Claude at effort level: none
- Step 2 — Analyze and reason → Claude at effort level: high
- Step 3 — Format output → Claude at effort level: low
The result is a workflow that spends compute where it counts and saves money everywhere else.
MindStudio supports all major Claude models alongside 200+ other AI models, so you can also mix Claude with other models depending on what each step needs. If a task doesn’t require Claude’s reasoning depth at all, you can swap it for a faster, cheaper model at that step. You can try MindStudio free at mindstudio.ai and start building without any API keys or separate accounts.
For teams building agentic AI workflows, the ability to configure effort levels per step — rather than per workflow — is one of the more underappreciated features of how MindStudio structures its builder.
Common Mistakes When Choosing Effort Levels
A few patterns come up repeatedly when builders misconfigure effort levels:
Over-indexing on max. Many developers default to max because they want the best possible output. But on most tasks, high or medium produces nearly identical results at significantly lower cost. Max is for genuinely hard problems, not for general quality improvement.
Plans first. Then code.
Remy writes the spec, manages the build, and ships the app.
Using none on ambiguous inputs. None is great for deterministic tasks. If your input can vary significantly in structure or content, zero thinking budget means Claude has no runway to handle edge cases gracefully. Even low effort helps here.
Not profiling before scaling. It’s common to build a workflow at high effort, confirm it works, and then deploy it at scale without checking whether medium would have been sufficient. A 2x cost difference at 10 calls/day becomes a major line item at 10,000 calls/day.
Ignoring latency constraints. High and max effort levels add meaningful latency. If your workflow is user-facing — a chatbot, a real-time assistant, a live content tool — you need to account for that in your UX design.
Applying the same level to every step. The biggest optimization opportunity in any multi-step workflow is matching effort to task complexity at each individual step. Treat it as a per-step decision, not a workflow-wide setting.
FAQ
What is Claude’s extended thinking feature?
Claude’s extended thinking is an internal reasoning process that happens before Claude generates its final response. When you enable extended thinking and set a thinking budget, Claude uses that budget to work through a problem step by step before committing to an answer. The reasoning chain is typically hidden from end users — only the final response is returned. Higher effort levels expand this thinking budget, giving Claude more room to reason.
How do Claude effort levels affect cost?
Each effort level adds thinking tokens to your call, and thinking tokens count toward your total usage. As you move from none to max, the cost of each API call increases — roughly doubling at each step up. For low-volume use, this difference is small. For high-volume workflows, it compounds significantly. Profiling your tasks and using the lowest effort level that produces acceptable output is the most effective way to control costs.
When should I use max effort in Claude?
Use max effort when accuracy is critical and the task is genuinely complex. Good candidates include: hard reasoning or math problems, complex code review, formal logic verification, autonomous agents that need to plan across many steps, or research synthesis tasks where missing a nuance has downstream consequences. On most everyday tasks — content generation, data extraction, structured output — medium or high is sufficient and significantly cheaper.
Can I use different effort levels within the same workflow?
Yes, and you should. Different steps within a workflow have different reasoning requirements. A data parsing step needs no reasoning budget at all. An analysis step might need high. A formatting step needs none again. Matching effort levels to individual steps — rather than applying a single setting workflow-wide — is one of the most effective ways to optimize cost and performance in production.
Does a higher effort level always produce better output?
Not always. For simple tasks, higher effort levels produce essentially identical output with more latency and cost. The quality improvement from increasing effort is most pronounced on tasks that genuinely require reasoning: multi-constraint problems, ambiguous inputs, tasks requiring planning or verification. For clear, deterministic tasks, the extra compute doesn’t meaningfully change the result.
What’s the difference between effort level and model selection?
These are separate dimensions. Model selection determines which Claude version you’re using (and its baseline capability). Effort level controls how much extended thinking that model applies to a specific task. You can run Claude Fable 5 at low effort, or a lighter Claude model at max effort. For cost optimization, model selection and effort level should both be considered together.
Key Takeaways
- Claude’s five effort levels — none, low, medium, high, and max — control how much reasoning Claude applies before generating a response.
- Higher effort levels produce better results on complex tasks but increase both cost and latency significantly.
- Most standard business tasks run well at medium effort. Reserve high and max for genuinely complex reasoning, agentic planning, or accuracy-critical workflows.
- The most effective optimization strategy is applying different effort levels to different steps within a workflow, not using a single setting throughout.
- Tools like MindStudio let you configure effort levels per workflow step without code, making it practical to build cost-efficient multi-step agents that spend compute only where it matters.
Start with medium, profile your outputs, and step up only when you have a clear reason to. That discipline alone can cut your AI infrastructure costs in half without touching output quality on the tasks that matter most.
