Claude Code ultrathink Upgrade: Maxing Out Per-Turn Reasoning Effort at xhigh

Claude Code's "ultrathink" keyword is no longer just a prompt easter egg. Starting with version 2.1.311, typing ultrathink in the input box pushes the reasoning effort of that round of conversation straight to xhigh effort. On the surface this looks like just one more tier, but in practice it hands control of "allocating compute on demand" back to the developer.

What ultrathink Actually Changes

In Claude Code, effort (reasoning intensity) is an invisible dial that runs through every request. The higher the tier, the longer the model is "willing to spend" before giving an answer, the more complete the intermediate reasoning chain, and the lower the error rate on tasks like complex refactoring and cross-file debugging. What ultrathink does is temporarily turn the dial to xhigh within a single round of conversation, rather than globally changing the configuration.

This means you can keep the default intensity across a long session and only call out ultrathink on the round that genuinely needs deep thinking. For users accustomed to "the same tier from start to finish in one session," this is a more finely grained way to schedule compute.

Reasoning effort and the intermediate reasoning chain

In modern large model APIs, effort usually refers to the compute budget the model is allowed to invest before returning a final answer, commonly implemented by controlling the number of "thinking tokens" or sampling steps. With high effort enabled, the model first generates an internal reasoning process that is not directly shown to the user (the intermediate reasoning chain, chain of thought), then gives its conclusion based on it. The longer this chain, the more opportunity the model has to decompose sub-problems, self-check, and backtrack from wrong branches, so accuracy is higher on multi-step reasoning tasks. The cost is increased response latency and higher token consumption—the reasoning chain itself is also billed. This means effort is essentially a cost-versus-quality tradeoff dial, not simply a "smarter" switch.

Supported Range and Conditions for Taking Effect

According to the source information, this behavior covers four models: Opus 5.5, Sonnet 5.5, Haiku 5.5, and Fable 5.1. In other words, everything from flagship to lightweight models is within the effective range; ultrathink is not a privilege exclusive to some large model.

The source also mentions "when it works, when it does not, and caps"—that is, there are boundaries for taking effect and upper-limit constraints. This is worth noting: ultrathink does not unconditionally max out reasoning; actual behavior is affected by specific scenarios and quota limits. The original text does not elaborate on the details, but it reminds us not to treat ultrathink as a universal switch—it is closer to "raise as much as possible under current conditions" than "ignore all constraints."

What the "xhigh" tier and caps mean

In most reasoning intensity tiering systems, tiers usually progress from low, medium, high to the higher xhigh, and xhigh is a near-top tier rather than an absolute ceiling. So-called caps (upper-limit constraints) generally refer to reasoning token budgets, rate limits, or quota allowances set by the server for a single request or a single session. When the model's actually available reasoning budget is truncated by these constraints, even if xhigh is specified, the intensity that truly takes effect may be lower than the nominal value. This explains why the gains from several consecutive rounds of ultrathink may diminish: once the threshold is reached, subsequent requests get capped. Understanding this helps with correct attribution—poor results are more likely due to quota limits than to the keyword not being recognized.

Impact on Daily Development Workflows

The most direct change is that the mental model for cost and latency has shifted. In the past, to use high-intensity reasoning you either had to raise the configuration globally or switch to a stronger model; now you can switch round by round within the same session. When debugging a bizarre concurrency issue, ultrathink for one round, then switch back to normal intensity to write boilerplate code after fixing it—compute is spent where it matters.

Another implicit benefit is in collaboration scenarios. Team-shared Claude Code configurations tend to be conservative, avoiding high consumption on every request. ultrathink provides a path for "an individual to temporarily raise the stakes" without changing team-level settings or affecting others' default experience.

Usage Recommendations and Caveats

First, reserve ultrathink for tasks that genuinely require multi-step reasoning, such as cross-file architectural adjustments, locating hard-to-reproduce bugs, and deep review of existing code logic. Using it for daily completions or typo fixes yields little benefit.

Second, keep in mind that caps exist. Since there are upper-limit constraints, several consecutive rounds of ultrathink may hit the threshold, and actual performance may not improve linearly. When results fall short of expectations, first confirm whether the limit has already been reached rather than suspecting the keyword did not take effect.

Third, model choice still matters. ultrathink raises reasoning intensity but does not change the model's own capability boundaries. How to trade off a lightweight model at full intensity against a flagship model at default intensity requires hands-on testing by task type.

A Signal: Reasoning Effort Is Becoming a First-Class Citizen

From global configuration to per-round commands, the granularity of reasoning intensity control is getting finer. Behind this is rising user demand for "controllability" as model capabilities improve—people no longer care only about whether the model can get it right, but also about how much it cost to get it right. ultrathink is a small step on this evolutionary line, but the direction it points is clear: in future AI coding tools, effort will become a standard parameter developers adjust daily, alongside temperature and context window.

Why effort is becoming a "first-class citizen"

In the parameter spectrum of AI coding tools, temperature controls output randomness, context window determines the amount of visible information, and effort controls "depth of thinking"—the three correspond to the orthogonal dimensions of creativity, information scope, and reasoning investment. Early products often hid effort in global configuration because model capabilities were limited and the returns from tuning were unstable; as model performance on complex tasks becomes increasingly sensitive to reasoning budget, exposing effort as a per-round adjustable parameter has gone from a niche option to a necessary capability. This also aligns with the logic of cost engineering: not every request deserves a high budget, and on-demand allocation is more economical than maxing out globally. Keywords like ultrathink are essentially a lightweight syntactic sugar for the effort parameter within a session.