Test-Time Compute Games

• Test-Time Compute Games are a formal framework that models how agents choose compute levels under explicit resource constraints during inference.
• They integrate computational complexity, game theory, and mechanism design to analyze strategies like Monte Carlo Tree Search, prompt selection, and auction-based pricing.
• Applications span AI inference, LLM reasoning, and cloud market simulations, illustrating key trade-offs between computational cost, performance, and fairness.

Test-time compute games formalize the interaction of agents or systems that must strategically decide, at test time, how much computation to expend given explicit resource (e.g., time, compute, or cost) constraints. These games arise in machine learning, automated reasoning, and mechanism design contexts, especially where inference costs scale with additional planning or sampling. Test-time compute (TTC) strategies include procedures such as Monte Carlo Tree Search at inference, large-scale prompt generation and selection, majority voting, and best-of-n sampling. The analysis of compute games intersects computational complexity, game theory, and multi-agent system design, with significant ramifications for both the efficiency and fairness of contemporary AI services.

1. Foundations and Formal Models

Test-time compute games explore strategic decision-making under explicit computational resource bounds, typically at inference rather than training. Formally, agents are modeled as players in a parameterized game arena $\mathcal{G} = \{G_k: k \in \mathbb{N}\}$ where, for each problem instance or size parameter $k$, participants select strategies implemented by Turing machines with worst-case complexity constraints (e.g., polynomial or exponential time) (Dima et al., 2023).

A TTC agent chooses an allocation $\theta$ from a finite set $\Theta$ of compute levels, which affects both output quality $q(\theta)$ and cost $c(\theta)$. In market-oriented variants, particularly in “LLM-as-a-service” settings, providers set prices $p(\theta)$, and users evaluate net value $V(\theta) = q(\theta) - p(\theta)$. The agent’s objective is to maximize utility (profit or reward) while adhering to the resource bound. Crucially, the feasibility of a strategy is conditional on it being executable within the target complexity class over all (or parameterized families of) problem instances (Velasco et al., 29 Jan 2026, Dima et al., 2023).

2. Hierarchies and Computationally Feasible Strategies

Test-time compute games distinguish between uniform and adaptive computational strategies. A uniform strategy is a single Turing machine (algorithm) that works for all input sizes or task instances, subject to a class $C$ (e.g., $\mathsf{P}$, $\mathsf{EXP}$). Adaptive (non-uniform) strategies allow for a potentially distinct algorithm per instance or parameter $k$.

A strict hierarchy is provable: allowing exponential-time (EXP) strategies strictly increases the strategic ability of agents over polynomial-time (P) ones, unless $\mathsf{P}=\mathsf{NP}$. For parameterized arenas, this yields:

$\Strat_{\mathsf{P}}(\mathcal{G},\varphi) \subsetneq \Strat_{\mathsf{EXP}}(\mathcal{G},\varphi)$

Adaptive ability does not coincide with uniform ability—there exist settings where adaptive $\mathsf{P}$-ability is achievable but uniform $\mathsf{P}$-ability is not. This divergence parallels the difference between uniform and non-uniform complexity classes (Dima et al., 2023).

3. Mechanisms and Game-Theoretic Analysis

Test-time compute games in machine learning and cloud inference markets are often modeled as non-cooperative games among providers, each optimizing profit by choosing compute levels and related pricing to attract users. Two regimes are prominent:

• Pay-per-token markets: Providers select $\theta$ and offer prices $p(\theta)$; users select the provider maximizing $V_i = q_i(\theta_i) - p_i(\theta_i)$. The Nash equilibrium often leads to inefficiency, with providers overspending on TTC beyond the social optimum, as marginal quality gains plateau but profit incentives remain (Velasco et al., 29 Jan 2026).
• Reverse second-price (scoring) auctions: To address inefficiency, mechanisms are introduced where providers bid quality–price pairs, and allocation/payment is determined by marginal value relative to a runner-up. Providers’ dominant strategy is to bid $p_i = c_i(\theta_i)$ and select $\theta_i$ maximally improving $q_i(\theta_i)-c_i(\theta_i)$. At dominant-strategy equilibrium, social welfare is fully optimized and the price of anarchy (PoA) is $1$ (Velasco et al., 29 Jan 2026).

The choice of mechanism modulates the degree of incentive alignment and welfare optimality, with auction-based approaches eliminating strategic overconsumption of compute.

4. Applications and Empirical Studies

Test-time compute games underpin several recent advances in AI and empirical benchmarks.

• Game Learning with Test-Time Planning: The decoupling of training and inference is exemplified in AlphaZero-inspired methods where Monte Carlo Tree Search (MCTS) is used only at test time to improve performance of temporally-difference-trained agents. This hybrid approach permits resource-efficient training, manageable on commodity hardware, and competitive play via costly inference-stage lookahead. Empirically, MCTS wrapping at test time enables significant improvements in win rates against strong game solvers, even when base value networks are trained without planning (Scheiermann et al., 2022).
• LLM Reasoning and Competitive Programming: In high-stakes programming tasks (e.g., IOI), scalable test-time compute methods such as GenCluster leverage massive candidate generation, behavioral clustering, peer-testing, and strategic submission to maximize problem-solving success within submission and resource constraints. Performance scales logarithmically with compute, and such frameworks have closed performance gaps with proprietary closed-weight models (Samadi et al., 16 Oct 2025).
• Market Simulations: Experiments comparing pay-per-token games and auction mechanisms confirm substantial inefficiency (up to 19% PoA) in conventional markets, and demonstrate that incentive-compatible auctions can increase net user value by 25–30% (Velasco et al., 29 Jan 2026).

5. Complexity and Model-Checking

The synthesis and verification of TTC-bounded strategies poses formidable computational challenges.

• Model-checking for uniform (single-algorithm) strategies in a parameterized family of games is undecidable, even for safety (invariant) objectives and single agents, whenever the allowed complexity class encompasses linear time.
• Model-checking is also undecidable for fixed games with two-player coalitions and polynomial-time classes.
• Restriction to decidable fragments is possible, for example, in single-instance imperfect-information games or bounded-energy systems, by reduction to finite parity games (Dima et al., 2023).

This theoretical landscape underscores the deep complexity of automating test-time compute–constrained planning and strategy synthesis in general settings.

6. Limitations, Variants, and Open Directions

Practical deployment of test-time compute games bears several limitations and open research problems. Strategic modeling typically idealizes quality contributions as additive in compute; real systems exhibit non-additive effects and unpredictable heuristics. Auction-based mechanisms require both robust and honest quality estimates, and may be vulnerable to provider collusion if improperly designed. Extensions to multi-parameter auctions, collusion-proof mechanisms, and dynamic multi-stage compute decisions are compelling future directions (Velasco et al., 29 Jan 2026).

Other significant avenues include:

• Incorporation of randomized or probabilistic strategies for adversarial or cryptographic domains (Dima et al., 2023).
• Online/interactive Turing machines with persistent state for multi-stage planning.
• Application to resource-bounded protocol synthesis, multi-robot planning under CPU constraints, and human-in-the-loop mixed autonomy.
• Tightening complexity-theoretic bounds within decidable subcases.

A plausible implication is that test-time compute games, by explicitly modeling the intersection of computation, strategy, and resource cost, provide a foundational language for analyzing and improving the efficiency, transparency, and fairness of advanced AI systems across both academic and commercial domains.