Why Fable 5.2’s maximum reasoning mode can be more expensive and worse

Fable 5.2 is a language model with adjustable reasoning depth: a separate model is not created for each level. The mode determines how much computation and how many internal steps the model devotes to the task. Increasing the depth sometimes improves quality, but a better answer is not guaranteed, and the final cost almost always needs to be checked.

This was especially clear in Frontier Code 2.0: at the Extra High level, Fable 5.2 scored 49,1%, while in maximum mode the result fell to 45,6%. The cost of one task meanwhile increased from 14,19 to 44,70 dollars.

What is excessive reasoning by Fable 5.2

Excessive reasoning occurs when a model continues analyzing a task after it has already found a sufficient path to a solution. It considers additional options, repeatedly checks intermediate conclusions, calls tools, or builds a longer plan even though these actions no longer improve the final result. In Anthropic’s materials, this effect is explained by the fact that Fable 5.2 can perform more work than a particular request requires.

For a developer, this does not look like an obvious error. The answer may be detailed, confident, and formally accurate, yet the extra steps increase latency, token usage, and the likelihood of deviating from the test criterion. In an agentic task, the model may sometimes start optimizing not the end result but the search process itself: creating additional iterations, changing an already acceptable solution, and returning to areas that have already been checked.

Extra High and maximum mode: a comparison on one task

The maximum mode turned out to be approximately 3,15 times more expensive than Extra High, although the test score fell by 3,5 percentage points. This does not prove that Extra High is always better: the comparison concerns the cited Frontier Code 2.0 run, not all tasks and configurations. It shows something else: a setting with a larger reasoning limit should be treated as a separate operating mode and tested on your own data.

Why did the additional computation not help? The benchmark tests a specific set of actions, not an abstract ability to “think longer.” Additional analysis may have led to a change in the correct strategy, excessive time spent on secondary details, or a violation of the expected answer format. In tool-based tasks, an extra cycle can also create new errors: each call adds state, intermediate data, and an opportunity to misinterpret the result.

Task cost matters more than the price of one token

The token price shows only the pricing component. The actual cost of a task includes the input context, hidden reasoning, tool responses, repeated calls, verification results, and the final answer. If an agent reads the same file several times or returns large search results to the context, the cost increases even when the price of an individual token remains unchanged.

According to Artificial Analysis specialists, in the cited trials the average cost of a Fable 5.2 task with maximum settings reached 26,50 dollars. This is approximately 2,6 times the Opus 5.5 figure and approximately twice the Fable 5.1 figure. In one test set, Fable 5.2 generated around 275 million tokens, compared with a median of approximately 72,8 million. These figures describe usage in a specific test set, not the mandatory cost of every request to the model.

The practical calculation looks like this: the cost of a task equals the sum of input tokens, output tokens, and all intermediate calls, multiplied by the provider’s current rates. This total should also include tool costs, result storage, and repeat runs if the platform bills them separately. To compare modes, record not only the bill but also the number of calls, total token volume, execution time, and the share of tasks completed without human intervention.

Where maximum mode is justified

Maximum reasoning depth is justified where additional searching genuinely increases the value of the result: in long mathematical proofs, complex code analysis, multistep tool use, and tasks where an error is costly to discover after the process is complete. Even in these scenarios, the limit should be tied to a success criterion rather than enabled by default.

• Complex development. Maximum mode can be applied to architectural decisions, migrating a large project, and finding the cause of a difficult-to-reproduce failure, if the result passes automated tests.
• Research analysis. High depth is useful when comparing many sources and checking competing hypotheses, provided the structure of the final report is defined in advance.
• Long-running agentic tasks. The mode makes sense for sequential execution of actions if the agent receives feedback from the environment and knows how to stop after reaching the goal.

In the Perplexity Web test, Fable 5.2, according to the cited description, achieved comparable or better results at costs of around 40% of Opus’s costs. In graph-analysis tasks, costs sometimes amounted to less than 10% of Opus’s costs. This result is important as an example of how economics depend on task type: the same model can be expensive in autonomous programming and comparatively cost-effective in visual-data analysis.

When a high mode is sufficient

Extra High or another high but not maximum level is more reasonable for most tasks with a clear completion criterion: fixing an error, preparing a brief report, extracting data, transforming text, or writing a function with tests. Here, additional reasoning after the criterion has been met rarely creates proportional value, while increasing the bill and waiting time.

What should you do if a task looks complex but cannot be assessed in advance? Run an inexpensive trial on a limited context, record the metrics, and only then increase the depth. This two-stage process is better than permanently using maximum mode: first, the model builds a working solution, and then the more expensive configuration checks only the disputed areas.

Practical budget control rules

1. Separate modes by task type. For classification, extraction, and short editing, assign a low or medium level. For code and research, use a high level only after testing it on your own sample.
2. Set limits on tokens and steps. The limit should account not only for the final answer but also for the number of tool calls, retries, and verification cycles.
3. Define a stopping condition. In the prompt, specify what result is considered sufficient: passing tests, a completed table, identified discrepancies, or a report of a specified length.
4. Do not confuse answer length with quality. A detailed explanation does not compensate for an incorrect conclusion, unnecessary code, or a format violation. Evaluate the verifiable result.
5. Compare the median and outliers. The average cost can rise sharply because of a few runs in which the agent generated hundreds of millions of tokens. The budget must account for both typical usage and the rare but expensive scenario.
6. Keep a human in the loop at costly transition points. Before launching a long autonomous chain, check the plan, available tools, and maximum budget. Confirmation is especially useful before repeated iterations and large-scale execution.

Is maximum mode needed for every complex request? No. First determine exactly what error the additional analysis is supposed to fix. If the problem is missing data, a poor prompt, the wrong tool, or inadequate result verification, increasing reasoning depth will not solve the root cause.

Takeaway for an API developer

Fable 5.2 should be selected not by the highest score in a single ranking, but by the combination of quality, cost, time, and result stability. The cited Frontier Code 2.0 example shows that maximum mode can produce a lower result for 44,70 dollars instead of 14,19 dollars. Artificial Analysis data also point to the risk of very high token usage, while the Perplexity Web test shows that in certain scenarios the same model can operate at a significantly lower cost than a competitor.

The working strategy is simple: start with Extra High, measure quality on your own sample, set limits, and enable maximum mode only for tasks where the additional computation passes validation and pays for itself in the result. With this approach, reasoning depth becomes a controllable budget parameter rather than a sign of automatically higher quality.