Your AI Has a Default Setting. Does It Actually Matter?

When a tech company sets a default setting on an app, most users never change it. This inertia—the path of least resistance—is so powerful that it's reshaped everything from pension contributions to energy tariffs. But new research reveals a crucial exception: when it comes to AI reasoning services, defaults may have far less power than we assumed, at least under certain conditions.

A team from Bilkent University has developed the first formal framework for understanding how LLM providers should price their services and set default reasoning allocations. Their counterintuitive finding is that defaults only shape user behavior when people place explicit value on the convenience of not customizing. In all other cases, the mathematics of the market ensure that whatever allocation the user would have chosen anyway will prevail—whether they actively select it or simply accept the preconfigured option.

"We're not saying defaults don't matter," says co-author Melih Bastopcu. "We're saying they're inert under a common and important condition: when users are purely rational economic actors, the default gets silently rewritten to match their true preference."

The Core Problem: A Service Built on Thinking

Modern reasoning models don't just generate answers—they think. Before producing a response, these systems can allocate hundreds or thousands of tokens to chain-of-thought reasoning, exploring multiple paths and self-correcting along the way. This "test-time compute" dramatically improves accuracy on complex tasks like mathematics and scientific reasoning, but it comes at a cost: more tokens mean higher prices and longer waits.

Providers who offer these models face a three-dimensional challenge. They must set a per-token price, determine how much reasoning to perform by default, and somehow anticipate whether users will accept what they're given, tweak it, or take their business elsewhere.

The researchers modeled this as a Stackelberg game—a framework from game theory where one player moves first and the other responds. The provider commits to a price and default allocation; the user then decides whether to keep it, customize it, or leave.

The user's baseline expected utility when accepting the default is:

$$u_0(r,p)=vQ(r)-pT(r)-\theta t(r)$$

where $v$ is the value of a correct answer, $Q(r)$ is accuracy, $T(r)$ is billed tokens, and $t(r)$ is latency. The term $\theta$ captures how much the user hates waiting.

But here's where the structure gets interesting: accepting the default isn't purely about the math. The researchers included a parameter $\delta \ge 0$ representing the "convenience benefit" of not customizing—the cognitive ease and status-quo advantage that makes defaults attractive regardless of their actual content.

A Model That Fits Reality

Before diving into the equilibrium analysis, the researchers tested their assumptions against reality. They fitted their accuracy model—$Q(r)=D+A(1-e^{-br})$—to two compact open-weight reasoning models across five benchmarks spanning mathematics and science.

The fit was good. This exponential saturation model captured something fundamental: reasoning improves quickly at first, then the gains diminish. The first hundred reasoning tokens might boost accuracy from 40% to 65%, but the next hundred only get you from 65% to 72%.

The latency model was equally straightforward: $t(r)=t_0+cr$. Each reasoning token adds a fixed amount of waiting time. Combined with the linear billing model where total tokens equal base tokens plus reasoning tokens, the framework maps cleanly onto actual deployed services.

The Three-Regime Logic

The paper's central contribution is a complete characterization of what the provider should do. For any given price, the provider's optimal default follows a three-regime rule, and the entire equilibrium computation collapses to a one-dimensional price optimization.

The logic unfolds as follows. First, given a price $p$, the user's optimal customized allocation has a clean closed form. If the marginal accuracy value of reasoning exceeds its marginal cost—the price plus the latency penalty—then some reasoning makes sense. Specifically:

$$r_c(p)=\{\begin{array}{ll}0& \text{if }m(p)\ge ab\\ \frac{1}{b}\log \left(\frac{ab}{m(p)}\right)& \text{if }m(p)<ab\end{array}$$

where $m(p)=p+\theta c$ is the effective marginal cost and $ab=vAb$ is the marginal accuracy value.

But here's the key insight: at any price, the set of defaults the user will accept is either empty or a compact interval. If $\delta =0$—if the user places zero value on the convenience of not customizing—then the acceptable defaults collapse to a single point: the user's optimal customized allocation itself.

In other words, when users are purely economic, the provider can set any default they want, but the user will simply adjust it to $r_c(p)$. The default has been "silently customized" by rational arbitrage.

The acceptance region $\mathcal{D}(p)$ depends on whether the user gets utility from convenience:

$$\mathcal{D}(p)=\{\begin{array}{ll}[0,\overline{r}(p)]& \text{if }K(p)\ge a\\ [\underline{r}(p),\overline{r}(p)]& \text{if }K(p)<a\end{array}$$

When $\delta >0$, the interval widens, and defaults gain real power. A default within the acceptable range will be kept, and its value determines the actual reasoning allocation—not because it's optimal, but because the convenience benefit outweighs the cost of deviation.

What Defaults Can and Cannot Do

The researchers proved a striking result: the default has allocative power only when $\delta >0$. When $\delta =0$, every service-providing outcome implements $r_c(p)$, regardless of what the default was set to.

This isn't merely a mathematical artifact. It reflects a deep logic: if a user would have chosen the same allocation anyway, then keeping the default is equivalent to customizing. The allocation doesn't change; only the path to it does.

This finding has immediate practical implications. It suggests that for sophisticated users—those who carefully evaluate the tradeoff between reasoning and cost—providers should focus on pricing rather than default engineering. The price is what determines the true allocation.

But for the broader population, where $\delta$ is likely positive, defaults regain their traditional economic power. And the researchers' framework tells providers exactly how to exploit it: choose a default inside the acceptable interval that maximizes provider profit, subject to the price already set.

The equilibrium existence proof then shows that the provider serves if and only if the optimized service value is nonnegative. Service provision isn't automatic; it must clear a profitability threshold.

Why Model Characteristics Matter

The experimental results reveal that model and task characteristics matter enormously for equilibrium outcomes. The saturation parameter $b$ in the accuracy function—the rate at which reasoning gains diminish—shapes how aggressively users should customize.

For tasks where reasoning shows sharp early improvements (high $b$), users customize heavily. For tasks where gains are gradual and sustained (low $b$), they're willing to accept defaults that allocate generous reasoning budgets.

This suggests a heterogeneous equilibrium landscape. A math problem set where reasoning tokens provide crisp, obvious benefits might feature aggressive customization and fierce price competition. A scientific reasoning task where benefits accumulate slowly might feature higher defaults, higher prices, and more default-keepers.

The Road Ahead

The framework opens several directions for future work. Real deployments involve user heterogeneity—some users value accuracy more than others, some are more price-sensitive, some have higher convenience valuations. Extending the model to accommodate distributional assumptions about the user population would make it directly applicable to actual services.

There are also network effects to consider. If users can observe each other's allocations or if reputation matters, the game becomes more complex. And mechanism design—designing the service to maximize social welfare rather than provider profit—remains an open question.

The researchers focused on a single-provider setting, but competitive markets are the norm. How do defaults function when users can comparison-shop? Does the presence of alternatives make defaults more or less influential? The paper doesn't answer this, but its framework provides the conceptual tools to tackle it.

There's also the empirical question of $\delta$ itself. How large is the convenience benefit in practice? If it's small for most users, defaults matter less than traditional models suggest. If it's substantial for a large fraction of users, then default design becomes a primary lever for provider strategy.

The Deeper Lesson

The paper's most important contribution isn't technical—it's conceptual. By formalizing the interaction between pricing, defaults, and customization, it clarifies exactly when defaults matter and when they don't.

Defaults are most powerful when users value the path of least resistance itself. When users are purely economic—when they evaluate each option on its merits and adjust accordingly—the market erodes the default's influence. The equilibrium allocation is determined by fundamentals, not framing.

But when defaults carry convenience value, they regain their traditional power. And in that world, the provider's optimization problem becomes multidimensional and strategically rich: choosing both a price and a default that together shape user behavior.

For now, the practical implication is clear: before engineering a default, understand your users. If they're sophisticated, focus on pricing. If they're convenience-seekers, design the default carefully.

The full paper is available on arXiv, and the authors have released code for their equilibrium computation methods. For providers building the next generation of reasoning-as-a-service platforms, this framework offers both theoretical grounding and practical guidance.