Active-Prompt: Using Model Uncertainty to Pick the Best Chain-of-Thought Examples

Chain-of-thought prompting reliably improves LLM performance on complex reasoning tasks, but it depends on a choice that is usually made by gut feeling: which questions should serve as exemplars? The original Wei et al. (2022) paper crafted eight examples per benchmark, either picking them at random from the training set or composing them by hand. Auto-CoT automated the selection but relied on clustering and could not tell whether a chosen question was actually informative for the model. Active-Prompt, introduced in 'Active Prompting with Chain-of-Thought for Large Language Models' (arXiv:2302.12246, published at ACL 2024) by Shizhe Diao, Pengcheng Wang, Yong Lin, Rui Pan, Xiang Liu, and Tong Zhang from HKUST, the University of Toronto, the University of Hong Kong, and UIUC, replaces that guesswork with a principled uncertainty criterion borrowed from the active learning literature. The paper evaluates Active-Prompt on eight reasoning benchmarks and reports that the entropy-based variant achieves an average accuracy of 81.6% across all eight datasets using Codex code-davinci-002, compared to 72.5% for standard CoT and 79.1% for self-consistency with the same model.

Why fixed exemplar sets underperform

Standard CoT prompts include a fixed batch of worked examples prepended to each test question. Those examples were selected once, typically by the researchers who wrote the paper, and are then applied uniformly to every question in the benchmark regardless of whether they are actually helpful for that specific question type. The problem is that reasoning benchmarks span a wide range of sub-problems: GSM8K alone covers rate problems, geometry word problems, multi-step algebra, and unit conversion. A set of eight hand-picked examples is unlikely to represent that diversity optimally. The alternative, random selection, does no better in expectation. The Active-Prompt authors note that annotation is not actually expensive: writing CoT rationales for eight questions is a small task. The real cost is choosing the wrong eight questions. Their insight is that the model itself can tell you which questions are hardest to get right consistently, and those are precisely the questions where a good human-written rationale will add the most value.

The four-stage Active-Prompt pipeline

Active-Prompt runs in four sequential stages before any test-time inference. In stage one, the model is queried k times (the paper uses k=10 in the main experiments) on each question in a pool of candidate training examples, capped at 1,000 questions per dataset. Each of the k completions produces an answer, and those k answers are compared to measure how much the model disagrees with itself on that question. In stage two, the questions are ranked by their uncertainty score and the top n are selected, where n matches the exemplar count used by the original CoT paper for that benchmark (eight for GSM8K, seven for CommonsenseQA, six for StrategyQA, and so on). In stage three, a human annotator writes a chain-of-thought rationale and confirms the correct answer for each selected question, producing the final exemplar set. In stage four, those exemplars are prepended to every test question at inference time, with optional self-consistency decoding over 40 samples. The only human work in the entire loop is the annotation in stage three, and the number of questions to annotate is the same as in the original CoT setup.

• Stage 1, uncertainty estimation: query the model 10 times per candidate question and compute an uncertainty score from the spread of the k answers.
• Stage 2, selection: rank the pool of up to 1,000 candidates by uncertainty and select the top n most uncertain questions.
• Stage 3, annotation: a human writes chain-of-thought rationales for the selected questions, matching the annotation style of Wei et al. (2022).
• Stage 4, inference: use the annotated exemplars as the few-shot context for each test question, optionally with self-consistency over 40 samples at temperature 0.7.

How uncertainty is measured: disagreement, entropy, and variance

The paper introduces four candidate uncertainty metrics and compares them empirically. Disagreement counts the number of distinct answers among the k completions and divides by k: a question where all ten runs produce a different answer scores 1.0, while a question where all ten runs agree scores 0.1. Entropy computes the Shannon entropy of the answer frequency distribution: questions where the probability mass is spread evenly across many answers receive a high entropy score. Variance treats numeric answers as real numbers and computes their sample variance, with normalization by the numbers mentioned in the question to prevent large-magnitude answers from dominating the ranking. The fourth metric, self-confidence, asks the model to rate its own certainty after generating an answer. The paper finds that disagreement, entropy, and variance all perform comparably and substantially outperform self-confidence. The reason is that LLMs are prone to overconfidence: a model that is quite likely to produce a wrong answer will still often report being 'very confident.' Entropy-based uncertainty is recommended in the paper as the primary metric for its clean probabilistic interpretation.

Benchmark results across eight datasets

The paper evaluates on three categories of reasoning: arithmetic reasoning (GSM8K, ASDiv, SVAMP, AQuA, SingleEq), commonsense reasoning (CommonsenseQA, StrategyQA), and symbolic reasoning (last letter concatenation in an out-of-distribution four-letter setting). On code-davinci-002, standard CoT achieves 63.1% on GSM8K and an average of 72.5% across all eight datasets. Self-consistency raises those figures to 78.0% and 79.1%. Random-CoT, which uses the same annotation process as Active-Prompt but selects questions randomly, reaches 78.6% and 79.4%, showing that the annotation quality matters but is not alone sufficient. Active-Prompt with disagreement-based uncertainty reaches 82.2% on GSM8K and 80.9% on average. Active-Prompt with entropy reaches 83.4% on GSM8K and 81.6% on average. The gains are consistent across all three reasoning categories, not concentrated in one benchmark. On gpt-3.5-turbo-0613 without self-consistency decoding, CoT averages 78.5% and Active-Prompt (entropy) averages 81.0% across the same eight datasets.

Accuracy and uncertainty are inversely correlated

One of the ablation analyses in the paper confirms that the uncertainty criterion is selecting questions that are genuinely harder for the model, not just noisier. When questions are sorted by their disagreement score, the lower-uncertainty questions (those where the model is consistently right) show high accuracy, while the higher-uncertainty questions show low accuracy. This means the Active-Prompt selection is not arbitrary: it is systematically finding the questions where the model's existing knowledge is insufficient, and those are exactly the ones where a carefully written CoT rationale provides the largest lift. The paper also shows that Random-CoT, which uses human annotation but skips the uncertainty selection, closes some but not all of the gap relative to standard CoT, confirming that both the annotation quality and the selection strategy contribute to the final performance. The accuracy-uncertainty analysis is shown in Figure 4 of the paper.

Practical implementation and tradeoffs

Active-Prompt is straightforward to integrate into any CoT workflow that already has access to a pool of training questions. The main cost is the k forward passes per candidate question during uncertainty estimation: with a pool of 1,000 questions and k=10, the estimation stage requires 10,000 model calls before any annotation work begins. The paper finds that the performance gains plateau around k=10 and pool sizes around 1,000, so neither needs to be much larger in practice. The annotation step itself is bounded by the number of exemplars, which is typically 6 to 8, the same as the original CoT setup. One limit of the method is that it requires a labeled or at minimum a queryable training pool for the downstream task: it cannot be applied zero-shot in the way that analogical prompting or step-back prompting can. For tasks where no such pool exists, zero-shot CoT or zero-shot Active-Prompt (using the model's own zero-shot answers for uncertainty estimation) is shown to work, though with lower gains than the full pipeline. Code and evaluation scripts are available at github.com/shizhediao/active-prompt. PromptingIndex covers Active-Prompt alongside Auto-CoT, analogical prompting, and self-consistency as part of its series on automated and annotation-efficient few-shot reasoning strategies.