alignment5 min read

Inference-Time Alignment: Can Test-Time Compute Fix What Training Breaks?

MisalignAI|April 22, 2026|

inference-timealignmentscalingverificationai-safety

The dominant narrative in AI has been simple: bigger models, more data, longer training. But a quiet paradigm shift is happening at the other end of the pipeline 鈥?during inference, not training.

Researchers have found that allocating additional compute at test time 鈥?generating multiple reasoning paths, revising outputs, or using verifier-guided search 鈥?can outperform simply scaling model parameters [^snell-scaling]. The implication is radical: a smaller model with smart inference strategy can beat a model hundreds of times larger with naive sampling.

But there's a catch nobody talks about enough. Capability gains are real. Alignment gains? Much less certain.

How inference-time scaling works

The basic idea is straightforward. Instead of generating one answer and hoping it's right, the model generates many candidates, evaluates them against some criterion, and returns the best. Methods include:

Parallel sampling (Best-of-N): Generate N answers independently and pick the highest-scoring one.

Sequential revision: Generate an answer, critique it, revise, repeat.

Tree search: Explore reasoning paths like a chess engine, pruning low-value branches.

Verifier-guided search: Use a separate model to score candidate answers and guide the search.

Snell et al. (2024) showed that with optimal allocation, test-time compute can be more effective than parameter scaling [^snell-scaling]. Liu et al. (2025) pushed this further, demonstrating that a 1B parameter model with compute-optimal inference scaling can approach or surpass a 405B model with standard decoding [^liu-rethink].

The alignment angle

For safety researchers, the interesting question isn't whether inference-time scaling improves benchmark scores. It's whether it can serve as an alignment mechanism.

The intuition is appealing. If a model generates multiple reasoning paths, a verifier can reject deceptive or harmful ones before they reach the user. If the model revises its own outputs, it might catch its own [hallucinations](/blog/why-llms-hallucinate/) or [sycophantic](/blog/the-sycophancy-problem/) tendencies. The alignment isn't baked into the weights 鈥?it's enforced at runtime.

This is particularly relevant for [agentic systems](/blog/agentic-alignment-gap/), where a single error in a long chain of actions can compound catastrophically. Inference-time verification at each step could, in theory, prevent the "snowball effect" where small drifts accumulate into large misalignments.

The coverage problem

But Huang et al. (2025) identified a critical limitation: none of this works if the model can't generate the right answer in the first place [^huang-bestn]. Coverage 鈥?the probability that the model's generation distribution contains a correct answer at all 鈥?matters more than selection strategy. If the base model never produces a safe or truthful completion, no amount of test-time search will find one.

This is the ceiling. Inference-time methods can amplify capabilities that already exist in the model. They cannot create capabilities 鈥?or alignment 鈥?that were never there.

The verification bottleneck

Setlur et al. (2025) delivered the most important caveat: scaling test-time compute without a verification mechanism is suboptimal [^setlur-verify]. Generating more samples and picking the "best" one hits diminishing returns quickly if you have no reliable way to determine which one is actually best. Without a verifier, you're just generating more wrong answers faster.

The verifier itself becomes the alignment bottleneck. If the verifier is flawed 鈥?if it rewards confident wrong answers, if it shares the same [biases](/blog/the-invisible-bias/) as the base model, if it can be [deceived](/blog/ai-deception/) 鈥?then inference-time scaling just amplifies the deception at greater computational cost.

This creates a recursive problem: who verifies the verifier?

What it means for builders

Inference-time alignment is a genuine paradigm shift, but it's not a magic fix. It works best when:

The base model already has the right answer somewhere in its distribution (coverage).

The verification signal is more reliable than the generation signal.

The cost of additional inference compute is acceptable for the use case.

For high-stakes domains 鈥?medical advice, legal analysis, safety-critical agentic workflows 鈥?the cost of getting the verifier wrong is catastrophic. And as [capability evaluation](/blog/capability-evaluation-failure/) research has shown, we are not good at building verifiers that catch the failures that matter most.

Frequently Asked Questions

What is inference-time alignment? Inference-time alignment improves AI behavior by adding computation during the generation process 鈥?generating multiple candidates, revising outputs, or using verifier-guided search 鈥?rather than retraining the model. Snell et al. (2024) showed this can outperform parameter scaling [^snell-scaling].

Can inference-time scaling fix alignment problems? Partially. It can amplify existing safe behaviors if the model already generates them. But Huang et al. (2025) showed that coverage matters more than selection strategy [^huang-bestn] 鈥?if the model never produces safe completions, no search strategy will find them. And Setlur et al. (2025) proved that unverified scaling hits diminishing returns quickly [^setlur-verify].

What's the difference between inference-time scaling and RLHF? RLHF bakes alignment into the model weights through training. Inference-time alignment enforces constraints at runtime without modifying weights. The tradeoff: RLHF is permanent but brittle; inference-time is flexible but requires a reliable verifier and increases per-query cost.

What is the "coverage problem" in inference-time alignment? Coverage refers to whether the model's generation distribution contains a correct or safe answer at all. Inference-time methods can only select from what the model can generate. If the base model lacks the knowledge or values needed, no amount of test-time compute creates it [^huang-bestn].

---

[^snell-scaling]: Snell, C., et al. (2024). "Scaling LLM Test-Time Compute Optimally Can Be More Effective Than Scaling Model Parameters." arXiv preprint arXiv:2408.03314. https://arxiv.org/abs/2408.03314

[^liu-rethink]: Liu, R., et al. (2025). "Can 1B LLM Surpass 405B LLM? Rethinking Compute-Optimal Test-Time Scaling." arXiv preprint arXiv:2502.06703. https://arxiv.org/abs/2502.06703

[^huang-bestn]: Huang, A., et al. (2025). "Is Best-of-N the Best of Them? Coverage, Scaling, and Optimality in Inference-Time Alignment." arXiv preprint. https://arxiv.org/abs/2501.09620

[^setlur-verify]: Setlur, A., et al. (2025). "Scaling Test-Time Compute Without Verification or RL Is Suboptimal." arXiv preprint arXiv:2502.12118. https://arxiv.org/abs/2502.12118

---

DarkMental AI maps the structural shadows where more compute meets deeper questions.