Claude Fable 5.1 High vs Low Effort: Which Should You Use?

Pick the wrong effort level and Claude Fable 5.1 either wastes tokens or misses cases it should catch. Claude Fable 5.1 high vs low effort is a trade-off between spend and thoroughness. Use low for quick, well-defined work. Use high for hard jobs where one missed detail costs more than the tokens.

Anyone who plans to build an internal tool with AI hits this choice on day one. This guide compares both levels on reasoning, coding, agents, speed, token use, and cost per task. You will know which Fable 5.1 effort level to use for each job.

Fable 5.1 High and Low Effort at a Glance

Low effort is the fast, frugal setting. High effort is the thorough one. Both run the same model at the same rates, which Anthropic lists as $10 per million input tokens and $50 per million output tokens.

Sources: Anthropic's effort docs and a Claude Code engineering post.

Defaults depend on where you use the model. Anthropic says Fable 5.1 defaults to high in Claude Code and on the API. It defaults to medium in Claude Cowork and on Claude.ai.

What Effort Changes and What It Does Not

Effort sets how much work Claude Fable 5.1 puts into a reply. The effort docs say it applies to every output token: text, tool calls, and thinking. Claude Fable 5.1 effort levels run low, medium, high, xhigh, and max. This guide covers the two ends of the everyday range.

What changes between low and high effort

• With low effort, Claude uses fewer tools, starts working without a long introduction, and gives brief updates.
• With high effort, Claude uses more tools, tells you what it plans to do, and gives more detailed summaries and code comments.
• Low effort also means less time spent thinking. Claude may skip extra thinking for simple tasks but still thinks through difficult ones, though for less time.

What stays the same

• The model and the cost per token remain the same. Anthropic's docs explain that effort affects how the model behaves, not a fixed limit on token use.
• Effort levels do not work the same way across models. Anthropic's prompting guide recommends testing the effort levels again, even if you have already tested them on Fable 5.

Reasoning and Long-Horizon Work Compared

Fable 5.1 can handle difficult reasoning better at high effort. Even at low effort, it retains much of its ability. Anthropic also reports that Fable 5.1 outperforms Fable 5 at all effort levels, with the biggest improvements at higher settings.

At medium effort, it gets results close to Fable 5 at a lower cost. At low effort, it often scores higher than Opus and Sonnet models while costing about the same per task, according to the same prompting guide.

On Artificial Analysis’s current Intelligence Index v5.0, Fable 5.1 scores 38 at low effort, 49 at max, and 50 at xhigh. These figures come from Artificial Analysis’s updated Fable 5.1 model page. This means low effort retains about 78% of the max score.

Public data for high effort alone is limited, as most tests report results for low and max. So, the differences discussed in this article show the maximum possible gap between low and high effort.

Where high effort pulls ahead

The Claude Code engineering post breaks Terminal-Bench 3.0 into task types. Each pass rate below runs from Fable 5.1’s low setting to max.

• Hardware: 34% to 75%
• Security: 64% to 87%
• Machine learning: 54% to 73%
• Science: 41% to 61%
• Software: 43% to 56%
• Operations: 12% to 22%
• Media: 18% to 30%

Tasks with several hidden checks benefit the most from higher effort. Operations and media tasks still scored low, even at max effort.

The post also says these tests were run internally with safeguards turned off, so the results may differ from public leaderboard scores.

Long-horizon work

Anthropic designed Fable 5.1 to handle tasks that can take several hours. Its effort guide recommends xhigh for coding and agent tasks that run for more than 30 minutes and use millions of tokens. For these tasks, start with high and try xhigh. Low effort uses fewer tokens, but gives the model less time to review its plan.

Coding and Agentic Performance Compared

High effort finds more bugs in its own work. The gap is clearest on tasks with hidden edge cases.

Coding

One Terminal-Bench 3.0 task asks for an HTML sanitizer that blocks every way to hide JavaScript on a page. Fable 5.1 passed 1 of 5 attempts at low and 5 of 5 at xhigh. A low attempt wrote the filter in one pass and tested it on a single hand-written page.

A high-effort run reviewed its first draft as an attacker would. It then read the parser's source, ran a standard XSS test suite, and wrote a random-document fuzzer.

Across 370 attempts each, the failure counts moved like this:

• Missed edge cases: 59 at low, 24 at max
• Bugs its own tests missed: 40 at low, 14 at max

Not every coding task needs that depth. Red Hat told Anthropic that Fable 5.1 found the root cause of every broken build it tested, at all effort levels. The post's author drafts at low, reviews the result, and then verifies at high. That draft-then-verify loop is the kind of workflow you can set up with a coding agent builder, where you define the steps and the point where a person reviews.

Agents

Low effort is Anthropic's suggested home for subagents. A lead agent can run at high while its workers run at low. To build that split yourself, an AI agent builder lets you describe the lead agent and its workers in plain language. If you are wiring this up yourself, a guide on building AI agents from scratch covers the loop design.

You can also change effort inside one conversation. Anthropic's beta per-message setting keeps the prompt cache intact. Changing the top-level value between requests restarts the cache and steers Fable 5.1 less reliably, because it tends to stay consistent with its earlier replies.

Higher effort can also affect how Claude behaves when using multiple tools. Anthropic says Fable 5.1 sends fewer updates to users during long tool runs, especially at higher effort levels. If you want to see its progress, ask your client to show updates.

Speed, Token Use, and Cost Compared

The cost depends on the number of output tokens, and high effort uses many more. Thinking tokens also count as output and are charged at $50 per million tokens.

The table below compares low effort with the highest setting using two publicly available data points.

Artificial Analysis found that output token use varies by 11 times across the five effort levels. However, spending more does not always improve the results.On the current Intelligence Index v5.0, xhigh scores 50 and max scores 49. In Artificial Analysis’s launch-time cost analysis, xhigh cost $2.72 per task versus $3.76 at max—so max cost $1.04 more while scoring one point lower.

Here’s an example: Suppose a task uses 200,000 cached input tokens, 20,000 new input tokens, and 15,000 output tokens. Cache reads cost $0.05, new input costs $0.20, and output costs $0.75. That brings the total to $1.00.

Now, increase the output to 45,000 tokens. The output alone costs $2.25, bringing the total task cost to $2.50. These figures are examples, not benchmark results.

The launch cut helps either way. Cache reads now cost $0.25 per million tokens, 75% less than Fable 5. Anthropic estimates typical workloads cost about 25% less. For a deeper look at agent spending, read about AI agent cost.

Speed follows the same pattern. The HTML filter task took about 2 minutes at low and about 33 minutes at high. Anthropic's advice for slow runs is to lower effort.

What to log for cost per task

Track how much each task costs instead of relying only on benchmark scores. For every run, note the new input tokens, cache-read tokens, cache-write tokens and output tokens. Thinking tokens are part of the output count.

Use these rates: $10 per million fresh input tokens, $0.25 per million cache reads, $12.50 per million 5-minute cache writes, $20 per million 1-hour cache writes, and $50 per million output tokens, according to Artificial Analysis. Add the costs and divide by the number of successful tasks, not total runs.

This matters because a cheaper setting that fails half the tasks can end up costing twice as much for each completed task. Compare the cost of successful tasks at each level to see which one makes more sense.

Search and retrieval behavior at low effort

At low effort, Fable 5.1 uses search and retrieval tools less often than Fable 5. It relies more on what it already knows. Anthropic also points this out in its prompting guide.

This matters most for topics that change often, such as new models, software updates, and prices. Claude may give an outdated answer based on what it remembers and sound confident even when the information is wrong. You may not see an error message, just an incorrect answer.

Anthropic offers two fixes:

• Raise effort for that turn. The per-message setting changes the level without resetting the cache.
• Add a prompt rule. Tell the model that knowing a name is not the same as knowing its current state. Ask it to search for any name from a fast-moving area, using the name exactly as you wrote it.

You don't need either fix for tasks that don't rely on current information.

To test this, ask the same question about a recent release at low and high effort. Check whether both runs searched for information and whether their answers match the source. Try three or four questions to avoid relying on a lucky result.

Where Each Effort Level Falls Short

No single setting prevents every mistake. Choose the effort level based on what your task needs.

Low effort

• It can miss edge cases because it does less testing and stops sooner.
• It searches less, so it can return outdated facts.
• It gives the model less room to catch a flawed plan before acting.

High effort

• It is slower. The same task ran about 17 times longer at high than at low.
• It uses more tokens, which raises the bill on every run.
• It makes more choices for you. The post's author notes that higher effort means more assumptions when no one is in the loop.
• It does not fix a wrong approach. The engineering post found that extra effort cuts missed edge cases but not misread requirements.

More effort also does not guarantee fewer wrong answers. At max, Artificial Analysis found Fable 5.1 attempted 93.4% of knowledge questions and got more right. It also attempted more of the ones it missed.

Which Effort Level Should You Choose?

Which Fable 5.1 effort should I use depends on what a mistake costs. Use low when you can see and fix the result fast. Use high when the model works alone or when a missed case is expensive.

Test before you trust any table, including this one. Anthropic advises stepping down only after your own evaluations show quality holds.

• Pick 10 real tasks from your work.
• Run each at low, medium, and high.
• Score pass rate and record cost per task.
• Choose the lowest level that still passes.

If low on Fable 5.1 still costs more than the task is worth, consider a smaller Anthropic model. See what Claude Sonnet 5.5 and Claude Haiku 5.5 are, and how they differ.

Common mistakes when picking an effort level

Three habits waste the most money or time.

• Setting everything to high. Anthropic advises stepping down once your evals show quality holds. Routine, high-volume calls save the most at low.
• Judging on one prompt. The gaps in this article came from hundreds of attempts. One lucky or unlucky run tells you little.
• Counting only token price. A failed run still burns tokens, and rework burns your time. Measure cost per passing task.

Conclusion

Effort is the one Claude Fable 5.1 setting that moves both your bill and your results.

Key Takeaways:

• Low effort kept about 78% of max's Intelligence Index v5.0 score at a fraction of the tokens.
• Moving from low to max effort cut missed edge cases from 59 to 24 in Anthropic’s Terminal-Bench 3.0 runs; high effort should capture part—but not necessarily all—of that improvement.
• Low effort searches less, so fact-heavy turns need a search rule or a higher setting.

Try it on a real project. Emergent is an AI app builder, and Claude Fable 5.1 is live on the platform. Describe a tool, such as an internal dashboard builder for your team, and judge the result before you commit.