The Ultimate Guide to Claude Models and Effort: How to Save Tokens

Why can the same model differ in speed by dozens of times?

A developer used Opus at the Max Effort level to fix a bug, which took 8 minutes and consumed 15 times the weekly quota; after switching to the Low level, the same model completed the fix in just 17 seconds, and both fixes passed all hidden tests. This shows: The model hasn't changed; what changed is "Effort"—it determines how many tokens Claude is allowed to spend thinking, calling tools, and self-checking in a single request.

This article is based on a YouTube creator's systematic testing of 8 model and Effort combinations across 4 real coding tasks, combined with Anthropic's official benchmark data, to break down what scenarios each Claude model suits, what Effort actually changes, and how to configure for maximum token savings in daily development.

Four models: positioning and pricing from Haiku to Fable

Claude currently offers four models with clear differences in positioning and pricing:

• Haiku 5.5: The fastest and lowest-priced, at 10 cents per million input tokens and 50 cents per million output tokens. Suitable for high-concurrency simple tasks like classification and routing.
• Sonnet 5.5: Fast with still-strong capabilities, at $2 input and $10 output.
• Opus 5.5: The default model for Claude Code and Anthropic's official recommended starting point, at $4 input and $20 output.
• Fable 5.1: Designed for the hardest reasoning and long-horizon agent tasks, at $10 input and $50 output—output cost is 100 times that of Haiku.

All four models support a 1 million token context; the real differences lie in capability ceilings, response speed, and cost.

A context window refers to the maximum number of tokens a model can process in a single pass (including input and output). The four models mentioned in this article all support a 1 million token context, meaning they can read extremely long codebases, documents, or conversation histories at once without segmented truncation. However, context window size does not directly determine reasoning capability or cost efficiency; what truly affects actual performance is model parameter scale, training data, and the computational budget during inference (such as the Effort level). Therefore, in long-context scenarios, model and level selection should still be based on task complexity and cost, not merely on context length.

Effort levels: it's not just about "thinking time"

On top of the model, you also choose an Effort level: low, medium, high, x-high, max. Effort is essentially the token budget Claude is allowed to consume in a single request—including the thinking process, tool calls, and the depth of self-verification.

In the same bug case, Opus wrote about 1,500 tokens at the low level, about 4,000 at medium, and close to 60,000 at max. But note, this is a signal, not a hard cap: even at low, it will still think when encountering a genuinely difficult problem, just less.

In Claude Code, Haiku, Sonnet, and Opus default to starting at medium, while Fable starts at high. There are three ways to change it: type /effort to bring up a slider, or use /model with the left and right arrow keys; you can also add the claude --effort parameter when starting a session; or save a default level for each model in settings. Note that the max level is only effective within the current session. If you only want a specific question to think deeply, type UltraThink in the prompt and that turn will run at the x-high level.

A token is the basic unit of text processed by large language models, roughly corresponding to a word or word fragment. When a model generates a response, both input (prompt, context) and output (thinking process, tool calls, final answer) are measured in tokens, and the API charges by token count. The Effort level essentially sets a token budget for the model in a single request, determining how many tokens it can "spend" on internal reasoning, calling external tools, and self-checking. A higher budget allows more multi-step reasoning and verification, but cost and latency rise accordingly. Since the token budget is a soft signal rather than a hard cutoff, the model may think more than expected even at a lower level when encountering a genuinely difficult problem, but overall it tends to be more economical.

Real testing: 32 runs, 31 fully correct

The creator designed 4 real coding tasks—a buggy version range parser, a corrupted cache, a long voice function needing refactoring, and a cron scheduler to write per spec—and had the 8 model and Effort combinations execute them one by one, verifying results with hidden tests the models had never seen.

The results were surprising: 31 out of 32 runs passed all hidden tests, with the only failure being Haiku writing a function too long. In other words, on everyday coding tasks with clear boundaries, the choice of model and level had almost no impact on correctness—the real differences showed up in cost and time.

The cost gap is quite dramatic. Under the $20 per month Pro plan:

• Sonnet with medium can run about 4,000 such tasks per week;
• Opus with low, about 2,000;
• Opus with max, only about 160, taking over 20 times longer, without passing a single additional test;
• Fable passes everything but costs 2.5 times more per token than Opus, running only about 600 per week.

Anthropic's own benchmark data confirms this. In the SWE BenchPro test, Opus with medium solved 92.8% of tasks, and Fable with high solved 92.3%, but Fable's cost per solved task was about 5 times higher.

SWE BenchPro is a benchmark for evaluating AI models' ability to solve real software engineering problems. Tasks typically come from GitHub issues in open-source projects and require models to generate patches that pass hidden tests. This benchmark measures not only correctness but also the cost per task, because different models consume vastly different amounts of tokens during inference. The SWE BenchPro data cited in this article shows that Opus with medium achieves the best balance between correctness and cost, while Fable, despite similar correctness, costs several times more per task—providing objective grounds for everyday configuration.

When is high Effort actually useful?

On long-horizon, difficult tasks, raising Effort does work: Opus improved from 87% at low to 97% at x-high. But the cost is nearly 7 times higher per task. This reveals a key trade-off—the marginal benefit of Effort only appears when task difficulty is high enough, and is nearly zero for clear everyday tasks.

Practical configuration recommendations

Based on the testing data, here is a configuration strategy:

• Everyday coding, clear tasks: Use Opus or Sonnet with medium—this is already the default.
• Quick tasks where you'll check results one by one: Drop to low.
• Recurring bugs, scenarios where edge cases matter: Raise to high, or use UltraThink for individual prompts.
• Sub-agents and large batches of simple work: Use Haiku.
• Fable and max levels: Reserve only for problems where medium genuinely fails; don't treat them as defaults.

The core conclusion can be summed up in one sentence: Run with medium first, and raise the level only after failure, rather than maxing out from the start. Official benchmarks and independent testing are highly consistent on this point, making it the most memorable cross-validated conclusion from multiple sources in this article.