🤖 AI

Knowing When to Stop: Bayesian Optimal Stopping for LLM Evaluations

This paper introduces **optstop**, a Bayesian adaptive stopping framework that dynamically allocates sampling budgets based on uncertainty rather than fixed counts, enabling LLM evaluations to reduce computational costs by 57%–97% while maintaining equivalent conclusions.

Original authors: Toby D. Pilditch

Published 2026-08-17

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Toby D. Pilditch

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a detective trying to solve a mystery, but instead of a crime scene, you are investigating a super-smart robot brain called a Large Language Model (LLM). These robots are amazing; they can write stories, solve math problems, and even write code. But to know if they are actually smart or just guessing, humans have to test them on thousands of different questions. This is called "evaluation."

The problem is that testing is incredibly expensive and slow. Every time you ask the robot a question, it costs money and time to get an answer. Traditionally, scientists have used a "brute force" method: they ask the robot the exact same question 10 times, then 10 times for the next question, and so on, until they have a fixed number of answers for everything. It's like asking a friend, "Do you like pizza?" 100 times just to be absolutely sure they like it, even after they've said "Yes" with 100% confidence on the first three tries. This wastes a massive amount of resources.

The paper you are about to read introduces a new, smarter way to do this detective work. It uses a mathematical trick called "Bayesian inference" (which is just a fancy way of saying "updating your guess as you get new clues") to figure out exactly when to stop asking questions. Instead of a fixed number, it asks: "Do we know the answer well enough yet?" If the answer is yes, it stops immediately. If the answer is still fuzzy, it keeps going. This saves time, money, and energy, allowing us to test more models and more difficult questions without breaking the bank.

The "Stop Sign" for Robot Brains

Meet optstop. Think of it as a very smart, very patient traffic cop for testing AI.

Right now, when scientists test AI models, they usually follow a rigid rulebook: "Test every single question exactly 10 times." It doesn't matter if the AI gets the first 10 questions right instantly, or if it's struggling and getting them wrong. The rulebook says, "Keep going, you must do 10 tries." This is like a chef tasting a soup and deciding to stir it exactly 10 times, even if the soup is perfect after one stir, or if the pot is empty. It's inefficient.

The author of this paper, Toby D. Pilditch, asked a simple question: Why don't we stop when we already know the answer?

They built a new system called optstop that treats testing like a game of "Hot or Cold." As the AI answers questions, the system watches the "uncertainty."

If the AI is answering a math problem and gets it right 10 times in a row, the system says, "Okay, we are 99% sure it knows math. Let's stop testing this specific problem and move on."
If the AI is answering a tricky safety question and gets it wrong 5 times but right once, the system says, "Wait, that one 'right' answer is important! We aren't sure yet. Keep testing this one."

This isn't just about saving a few minutes. The paper shows that by using this "stop when you're sure" method, they could cut the number of tests needed by 57% to 97% in their experiments. That's like finishing a 100-mile race in 30 miles because you realized you were already at the finish line.

How It Works: The Three-Layer Cake

To understand how optstop is so good, imagine the testing process as a three-layer cake:

The Bottom Layer (The Items): These are the individual questions. Some are easy (the AI gets them right every time), and some are hard (the AI struggles).
The Middle Layer (The Tasks): These are groups of questions, like "Math" or "Writing."
The Top Layer (The Model): This is the AI itself.

Old methods treated every question the same. optstop looks at the whole cake. It realizes that if the AI is great at "Easy Math," it doesn't need to test every single easy math problem 10 times. It can stop early on the easy ones and spend its energy on the hard ones where the AI is confused.

The system uses a special kind of math (hierarchical Bayesian inference) to keep track of two things at once:

Precision: How sure are we? If the "confidence interval" (a fancy way of saying the range of possible answers) gets narrow enough, we stop.
Stability: Is the answer settling down? If the AI's answers stop changing much, we stop.

The "Conservative" Safety Net

There is one tricky part. What if the AI is really, really bad at something? Imagine an AI that only gets 1 out of 100 questions right. If you stop testing too early, you might think it gets 0% right, when actually it can do it, just rarely.

To fix this, optstop has a "conservatism" setting. If the AI is doing poorly, the system gets extra cautious. It says, "Hey, we might be missing a rare success! Let's keep testing even if the numbers look bad." It's like a parent checking a child's homework: if the child gets everything right, you stop checking. But if they get everything wrong, you check more carefully to make sure they didn't just have a bad day or miss a tiny detail.

The Results: A Massive Win for Efficiency

The author tested this idea with a huge experiment. They took 200 different questions and ran them through 10 rounds of testing (10 "epochs"). They compared the old "do everything 10 times" method against the new optstop method.

Here is what they found:

Huge Savings: In their tests, optstop skipped between 57% and 97% of the planned tests. In some cases, they only needed to run a tiny fraction of the tests to get the same result.
Same Accuracy: Even though they stopped early, the final score they gave the AI was almost identical to the score they would have gotten if they had run all the tests. The difference was so small (less than 0.01 on a scale of 0 to 1) that it didn't matter.
Different Scores, Different Savings: The system saved the most time on continuous scores (like a grade from 0 to 100) and the least on simple "Right/Wrong" scores, but it saved time in all cases.

Why This Matters

This isn't just a math trick; it's a game-changer for AI safety. Right now, testing AI is so expensive that labs can only test a few models or a few types of problems. If we can cut the testing time in half or more, we can test more models, more dangerous scenarios, and more complex tasks.

The paper proves that we don't need to waste energy on questions we've already answered. By letting the data tell us when to stop, we can make AI testing faster, cheaper, and more focused on the things that actually matter. It's the difference between blindly hammering a nail until it breaks and using a hammer that knows exactly when the nail is driven in.

In short, optstop teaches us that knowing when to stop is just as important as knowing how to start. And for the future of AI, that's a lesson we desperately need to learn.

Technical Summary: Knowing When to Stop: Bayesian Optimal Stopping for LLM Evaluations

1. Problem Statement

Current Large Language Model (LLM) evaluation practices predominantly rely on fixed sampling budgets, where every benchmark item is tested a predetermined number of times regardless of the precision of the resulting performance estimates. This "highest-number-is-best" approach often expends significant computational resources on items where estimates are already precise, while potentially failing to allocate sufficient resources to high-variance or rare-event scenarios.

The core methodological question addressed is whether current practices are systematically miscalibrated, leading to either wasted compute or premature termination before reliable conclusions can be drawn. Existing adaptive strategies, such as those based on Item Response Theory (IRT), typically require pre-calibrated item banks and often reduce the breadth of evaluation by selecting only the most informative items. Furthermore, standard frequentist approaches (e.g., confidence intervals based on sample means) often fail in evaluation contexts characterized by sparse, non-continuous, or hierarchically nested data.

2. Methodology: The optstop Framework

The paper introduces optstop, a precision-based adaptive stopping framework that treats LLM evaluation as a sequential measurement problem. The framework is implemented as a Python library compatible with the inspect_ai evaluation ecosystem and can operate in live or retrospective modes.

Core Principles

Precision-Based Stopping: The primary stopping criterion is the width of the posterior credible interval (CI) for a performance parameter. Sampling for a specific item or grouping terminates when the CI width ( $W$ ) falls below a user-specified threshold ( $\delta$ ). A secondary "stabilisation" criterion acts as a fallback, detecting when further data collection yields diminishing returns by monitoring the slope of CI width reductions.
Hierarchical Bayesian Inference: The framework explicitly models the nested structure of evaluation data (responses $\to$ items $\to$ groupings). It employs partial pooling to share information across items within a grouping, providing stable estimates even when individual items terminate at different points.
Asymmetric Conservatism: To address the risk of premature termination before rare but critical successes are observed (e.g., a model succeeding on only 1% of attempts), the framework applies an asymmetric adjustment. When estimated performance falls below a low threshold (default 1%), the effective CI width is inflated, and stabilisation thresholds are tightened, delaying stopping to allow for the observation of rare successes.

Inference Pathways

The framework supports three distinct inference pathways tailored to different score types:

Binary (0/1): Uses a logit-normal hierarchical model at the grouping level and an adaptive Beta model at the item level. The estimand is the population mean success probability.
Ordinal (Ordered Categories): Uses a hierarchical ordered logistic (cumulative link) model with a Dirichlet-Multinomial fallback. It employs a hybrid stopping criterion: Pathway 1 requires a narrow modal CI and low entropy (peaked distribution); Pathway 2 triggers if the entropy CI width converges (diffuse distribution).
Continuous (Bounded): Uses a hierarchical logit-normal model operating on item-level summary statistics (means) rather than individual observations, offering significant computational speedups.

Grouping and Routing

Groupings are user-defined partitions (e.g., Model $\times$ Task) that maintain independent inference states. The framework routes data to the appropriate pathway based on configuration (e.g., task name patterns or score aggregation settings) without requiring pre-calibrated item parameters.

3. Key Contributions

Adaptive Stopping without Pre-calibration: Unlike adaptive testing methods that require a pre-calibrated item bank, optstop keeps every benchmark item eligible for sampling, stopping only when statistical precision is achieved.
Unified Framework for Diverse Data Types: It provides a single mechanism for binary, ordinal, and continuous outcomes, handling the specific statistical challenges of each (e.g., entropy validation for ordinal data).
Safety-Oriented Conservatism: The introduction of an asymmetric conservatism mechanism specifically addresses the "pass@k" problem, ensuring that low-performance estimates do not trigger early stopping before rare capabilities are detected.
Live and Retrospective Utility: The tool functions as a live early-stopping protocol during evaluation runs and as a retrospective analysis tool for completed datasets.

4. Empirical Results

The framework was validated through a $3 \times 3$ matrix experiment crossing three inference pathways (binary, ordinal, continuous) with three performance levels (low, mid, high). The experiment utilized shadow mode, executing all 2,000 planned trials per cell while tracking when stopping criteria would have been met.

Efficiency Gains: The framework eliminated between 57.2% and 97.3% of planned trials across the nine validation settings.
- Continuous pathways achieved the highest efficiency (mean 95.1%), followed by ordinal (75.0%) and binary (73.3%).
- Extreme performance levels (near floor or ceiling) yielded greater savings than mid-range levels due to faster posterior convergence.
Score Fidelity: Despite massive trial reductions, the truncated estimates remained closely aligned with full-run results. The mean absolute score deviation across all cells was 0.006 on a normalized [0, 1] scale. The largest single-cell deviation (0.022) remained within the precision threshold ( $\delta = 0.05$ ).
Statistical Equivalence: Bayesian equivalence testing (HDI + ROPE) confirmed that truncation introduces negligible systematic bias. A hierarchical meta-analysis of the truncation effect across all cells yielded an overall mean difference of $\hat{\mu} = +0.0003$ with a 97% HDI of $[-0.002, +0.003]$ , entirely contained within the region of practical equivalence (ROPE).
Ranking Preservation: In ordinal and continuous columns, the relative performance rankings of models under different conditions (e.g., varying max_tokens) were preserved in both full-run and truncated conditions.

5. Significance and Claims

The paper claims that optstop transforms LLM evaluation from a fixed-budget exercise into a targeted resource reallocation strategy. By allocating compute based on uncertainty rather than fixed repetition counts, the framework allows practitioners to:

Reduce Costs: Significantly lower the computational and financial burden of comprehensive evaluations.
Enhance Sustainability: Reduce the environmental footprint of evaluation campaigns.
Improve Rigor: Focus resources on capability boundaries and rare-event scenarios where uncertainty is highest, rather than wasting effort on well-characterized model-task combinations.

The author emphasizes that the framework's validity relies on the exchangeability of observations within groupings and randomized item presentation order. While the current validation spans multiple pathways and benchmarks, the author modestly notes that broader replication across different evaluation contexts and scale sizes would further strengthen confidence in the framework's generalizability. The approach is presented not merely as an optimization but as an integral component of evaluation regimes that aim to be both rigorous and sustainable.