Reasoning Effort Tiers Explained: How to Choose Between Low, High, and Max
Reasoning effort settings like Low, High, and Max are widely misused. This article breaks down how each tier actually behaves in practice, why longer thinking is sometimes more expensive rather than cheaper, and how to design a routing strategy that picks the right tier per task. It includes a cost model, a pipeline-first verification approach, sample routing code, and guidance on building your own tier benchmark—so you can judge tiers by cost per effective output rather than by thinking length.
1. The Starting Point: Tiers Aren’t “The Harder You Push, The Better”
Over the past year, mainstream reasoning models have largely turned the “thinking budget” into an explicit, tunable parameter, commonly named Low / High / Max, with some platforms also offering an automatic tier that lets the model decide the reasoning length on its own. Model service platforms, including Baidu AI Cloud, typically expose this reasoning effort as a configurable option for callers as well, and pair it with logging, monitoring, and alerting to observe both quality and cost.
But in practice, the tier setting is widely misused. The common intuition is: since the Max tier thinks the longest, it must produce the highest quality, so you should just max it out whenever budget allows. Actual experience often shows the opposite—the Max tier repeatedly overturns itself during the solution-design phase, latency spikes and cost climbs, and the final output isn’t necessarily better than the High tier; while the Low tier, though it thinks very briefly, if the first-round plan goes off track, the subsequent fixes burn through many rounds and eat up the money you saved.
What really needs to be answered is not “which tier is best,” but three engineering questions: What are the behavioral differences between tiers? What components make up total cost, and how does each change with the tier? How can you automatically choose a tier based on task characteristics and verify the result?
2. Sample and Method
To make the conclusions discussable, I used a representative task that can also be automatically verified for a controlled comparison.
Task definition: Build a minimalist-style SVG emoji system page with 12 emotional states (anger, disgust, fear, sadness, surprise, happiness, calm, and their extensions), each with a continuously looping animated feature. The page supports smooth manual switching and includes an automatic switching mechanism with randomized rhythm drift.
I chose this task for three reasons: the requirements are clearly bounded and the result can be objectively verified (does it render, are the animations continuous, does switching work); there are multiple design paths to the implementation (SVG path morphing, attribute animation, CSS-variable-driven approaches, layered displacement, and so on), which produces real design forks; and it carries some creative demands, which lets us observe differences in the model’s aesthetic choices.
Dimensions recorded: thinking-process length (as a coarse proxy for input volume), whether the first-round plan was usable, number of editing and fix rounds, end-to-end elapsed time, token consumption per task, and the final visual quality.
It must be emphasized that this is an empirical observation from a single sample; results vary widely across model implementations, versions, and prompt styles. The numbers below serve only as an order-of-magnitude reference and should not be treated as a performance benchmark.
3. Behavioral Profiles of the Three Tiers
Low tier. It behaves like “handing in a draft first”: it quickly puts out a plan and immediately starts producing, with very short thinking length (only single-digit lines of reasoning on this task). The problem with this draft-style output isn’t the draft itself, but that the draft is too short—it usually locks onto a single implementation path without any feasibility check or consideration of edge cases. Once the first-round plan falls apart on a key technical point, the model can only make local patches on top of the existing code, editing over and over, and the final time and cost end up higher than the High or Max tiers. It suits scenarios with a narrow answer space, strong constraints, and correctness that can be judged automatically by external tooling.
High tier. This is the sweet spot for most tasks, and its core characteristic is adaptivity: simple problems converge quickly without stretching out the reasoning just to “look diligent”; complex problems unfold into engineering analysis, checking each option’s feasibility on data structures, state management, and exception branches before acting. Its thinking length correlates positively with problem complexity rather than with the tier ceiling, so it performs stably on the key metric of first-pass success rate. For this case study, its first-round output was basically runnable, with only minor adjustments afterward.
Max tier. Its behavior pattern is “multi-round self-review”: it first spends a long passage agonizing over the overall approach, then agonizes over implementation details for another round, then overturns several ideas and starts over, and only then finalizes and begins work. In tasks where the solution space is genuinely large and the cost of error is extremely high, this caution is valuable; but in this case, it showed diminishing returns on the same problem, and even got a detail wrong, adding to the rework. The conclusion: the Max tier is better suited to “irreversible design decisions, hard-to-verify, high-cost” scenarios, not everyday coding.
4. Cost Structure: Why Longer Thinking Is Sometimes Cheaper
Breaking total cost apart explains the counterintuitive phenomenon above:
Expected total cost = initial authoring cost C0 (including thinking) + (1 - P_pass) × K_fix × C_fix
where P_pass is the probability that the first-round plan passes on the first try, K_fix is the average number of fix rounds after failure, and C_fix is the cost of a single fix round. A set of hypothetical numbers illustrates it:
def expected_cost(c0, p_pass, k_fix, c_fix):return c0 + (1 - p_pass) * k_fix * c_fix# Values are illustrative assumptions, not measuredprint(expected_cost(c0=1.0, p_pass=0.40, k_fix=2.0, c_fix=1.2)) # Low tier ≈ 2.44print(expected_cost(c0=2.0, p_pass=0.85, k_fix=1.0, c_fix=1.0)) # High tier ≈ 2.15print(expected_cost(c0=3.5, p_pass=0.88, k_fix=1.0, c_fix=1.0)) # Max tier ≈ 3.62
The key is the amplification effect of the second term: fix cost is a product term—“failure probability multiplied by number of rounds”—while the first-round cost is just an addend. The Low tier saves on the addend but drives up the multiplier; the High tier pays more on the addend but pushes the multiplier close to zero. So when a task has a clear correctness criterion, raising the first-pass rate usually pays off more than compressing the first-round thinking. In the extreme case, the fix process itself can introduce new defects, causing cost to rise nonlinearly.
5. Moving Verification Cost from the Model to the Pipeline
The model above yields an important engineering corollary: there are two ways to raise P_pass—increase the thinking budget, or strengthen the external verification loop. The latter is usually the more sustainable approach.
Concrete means include: turning requirements into executable assertions (structural checks, snapshot comparisons, pixel-level screenshot comparison, interaction-script regression); splitting long tasks into small commits where each step can be independently verified; running static checks and accessibility checks on generated results; and injecting fixed seeds for stochastic behavior so it can be reproduced.
When the verification loop is strong enough, the Low tier’s risk shifts from “no safety net” to “failures are caught quickly and retried locally,” at which point the Low tier’s cost-effectiveness rises noticeably. Conversely, pushing the tier down without a verification loop is equivalent to staking quality entirely on the model’s first-round judgment.
6. A Tiered Routing Strategy
It’s best to make tier selection an explicit strategy rather than a single global value:
def choose_budget(task):# Narrow answer space, auto-verifiable: lower the budget, rely on the pipelineif task.has_hard_assertions() and task.estimated_files <= 2:return "low"# Cross-module design, interface contracts, irreversible decisions: raise the first-pass rateif task.crosses_module_boundary() or task.design_is_hard_to_reverse():return "high"# Exploratory/creative: start at the high tier with multiple samples, rather than just raising the tierif task.rewards_diversity():return "high"return "high" # Default tier
Paired with three practical principles:
Set the default to the High tier, and allow per-task overrides; treat “retry” as a separate budget item—for creative and exploratory tasks, running the High tier 3 times plus manual selection usually beats running the Max tier once; and record benchmark data separately for each tier, to avoid drawing a global conclusion from a single experience.
7. Building Your Own Tier Benchmark
Don’t inherit others’ tier evaluations; a small-sample evaluation on your own task distribution is enough. The evaluation set should have around 20–50 items, stratified into three categories—simple modification, medium implementation, and complex design—with several automatically verifiable problems kept in each.
Metrics to collect:
- First-pass success rate P_pass (most important; it maps directly to the multiplier in the cost model)- Average fix rounds and single-round fix cost- Token consumption and end-to-end elapsed time per task (compared across tiers)- Cost per effective output = total cost / number of passing cases- Human subjective ratings (used only for creative, readability, and aesthetic dimensions)
Two common interpretation traps deserve a warning. First, thinking-process length is not equal to reasoning budget: some platforms collapse or truncate the thinking display by default, showing only the first line, which has no necessary relation to the actual underlying effort—you can’t infer that the model “didn’t try hard” just because “the thinking you saw was short”; you need to cross-check with elapsed time and token consumption. Second, subjective aesthetics can’t be extrapolated: on creative tasks, the “potential” of a given tier’s output depends largely on subsequent human experimentation and selection, and shouldn’t be directly converted into a judgment of tier quality.
8. Conclusion
The Low, High, and Max tiers are not a ladder of quality, but different cost–risk distributions: the Low tier bets on first-round correctness, the Max tier buys design caution, and the High tier adapts between the two and is usually the default first choice. What really determines the outcome is the combination of three things: first-pass rate, fix rounds, and the verification loop. The practical recommendation is straightforward—default to the High tier, drop to the Low tier for simple and automatically verifiable tasks and back it with a pipeline, reserve the Max tier for high-cost and irreversible design tasks, and use multiple High-tier samples plus manual selection for creative exploration. At the same time, build your own stratified evaluation set and judge whether a tier was the right choice by cost per effective output, not by thinking length.
