Reasoning and Test-Time Compute

Computation before commitment

Test-time compute is computation performed while solving a new input. A reasoning policy decides what problem-solving work to perform: continue a calculation, generate another approach, inspect a proposed answer, revise it, or finish. These choices can happen within one model response or across several calls. Jack Rae’s Thinking Deeper in Gemini describes intermediate generation as an additional computation stage before the model commits to its answer. [1]

Model weights are learned numerical parameters. Training changes those parameters; the inference policies considered here use them without updating them. A model can be trained to deliberate or correct mistakes, then spend different amounts of computation on different requests. Post-training explains persistent parameter changes, including learning from feedback. Choosing additional reasoning work is also distinct from executing that work faster: Inference Engineering owns the serving machinery. [2][1]

A candidate is a proposed solution. Producing a good candidate and returning it are separate accomplishments. Ten attempts are useful only if their results justify the expense and the system can identify an acceptable one. A correct solution buried among rejected attempts does not help the person receiving a different answer. This distinction connects every mechanism in the chapter: generation creates opportunities; selection and stopping determine which opportunity becomes the result. [3]

Must-know turning points

Reasoning under limited resources predates language models. Exhaustively examining every possibility is often impractical, and a useful answer can arrive too late. Different traditions addressed which alternatives to explore, what counts as sufficient, and how to preserve a result when computation must end. [4][5][6]

An anytime procedure can return its current candidate when interrupted. That is a useful delivery property, not a promise that every additional revision improves the answer. These developments remain complementary: learned generation can propose alternatives, heuristics can prioritize them, and bounded-choice reasoning can determine when further improvement is unnecessary. [6][4]

Working through intermediate results

Deliberation is intermediate computational work before committing to an answer. In a text-generating model, a scratchpad records working state, and a reasoning trace is the generated sequence of intermediate steps. Text is generated in model-specific units called tokens. Earlier generated tokens become input to later generation, so a recorded intermediate result can affect what follows; autoregressive generation explains this dependency. [11]

The 2021 study Show Your Work explored scratchpads for arithmetic and program execution, including intermediate variable values. Some experiments trained on such working, so their gains were not purely inference interventions. The central mechanism is nevertheless concrete: instead of immediately predicting the final result, generation makes useful intermediate state available to subsequent steps. [11]

Consider computing $(8+7)\times3$. Recording $s=15$ lets the next operation use $3s=45$. Recording $s=14$ instead can lead to $42$, even if the multiplication is performed correctly. The later step is locally consistent with its working state but the complete solution is wrong. Decomposition exposes dependencies; it does not validate the values passed between them.

Chain-of-thought prompting elicits intermediate steps before the final answer. Wei and colleagues’ 2022 study supplied worked examples to encourage this behavior. Useful working was not interchangeable with extra text: generating a matching number of dots did not reproduce the arithmetic benefit, and placing the explanation after the answer performed approximately like the standard baseline. The distinction is whether intermediate work can contribute to the answer, not simply whether the response is long. Prompting and In-Context Learning develops the instruction and demonstration choices. [8]

Intermediate computation need not always become words. Coconut, introduced by Shibo Hao and colleagues at Meta FAIR and UC San Diego in December 2024, feeds an internal numerical representation—the last hidden-state vector—back as an input embedding. Its GPT-2-based experiments improved over a trained chain-of-thought baseline on ProsQA, a logical-reasoning benchmark, but underperformed it on GSM8K, a collection of grade-school math word problems. This requires specialized training and access to model internals, not a prompting switch. Representation learning explains the distinction between an object and its numerical representation. [12]

Expand ⤢

What a reasoning trace establishes

Three properties must be assessed separately. Answer correctness concerns the result. Step validity concerns whether the displayed argument follows from its premises. Faithfulness concerns whether that argument accurately represents the influences responsible for the model’s answer. A readable trace does not establish all three. [13][14]

In Reasoning Models Don’t Always Say What They Think, researchers compared answers with and without added hints. Tested models sometimes changed their answer toward a hint without acknowledging it in their reasoning. This identifies an omitted influence under the experiment, not every internal computation or deceptive intent. Separately, Let’s Verify Step by Step identified incorrect reasoning that nevertheless reached the correct final answer. Checking only the final value missed that defect. [13][14]

Visible working, a returned summary, and reported reasoning-token usage are also different observations. The Gemini documentation inspected in August 2026 distinguishes thought summaries from the complete internal thought sequence. Usage accounting describes resource consumption, not whether an explanation faithfully reports the computation. [15]

An engineering assessment therefore need not depend on reading hidden reasoning. Check the returned answer against the task, inspect displayed steps when their validity matters, and treat causal claims about reasoning as a separate investigation. A second model’s approving explanation remains a judgment requiring validation, not an independent proof. [16]

Sampling and agreement

Sampling draws a possible continuation from a model’s output distribution. Several attempts can explore alternatives that extending one attempt never reaches. Independent attempts do not consume one another’s answers; asking a later attempt to critique an earlier one is a different procedure. Independence of draws also does not create independent knowledge: the same model can repeatedly reproduce the same misconception. [17][3]

Temperature changes how concentrated token sampling is; it does not measure reasoning quality. Sampling controls determine how continuations are drawn. For this chapter, the key consequence is the candidate pool they produce. More samples may expose a successful solution without making that solution recognizable to the system. [18]

Self-consistency samples reasoning paths, extracts their final answers, and returns the most frequent answer. Equivalence must be defined before counting. For an exact dimensionless number, the following invented outputs form three groups; treating a rounded approximation as exact would change the task. [19]

The answer 1/2 wins with two of four votes: a plurality, meaning the largest count, rather than a strict majority. That count does not establish correctness. Voting can nevertheless improve accuracy: in the self-consistency study, unchanged PaLM-540B weights and prompts achieved 74.4% GSM8K accuracy with forty sampled outputs versus 56.5% with greedy chain-of-thought decoding, averaged over ten runs. Greedy decoding constructs one path by choosing a highest-scoring token at each step. The sampled procedure explored multiple paths and aggregated their answers, spending more work; this was not a cost-matched comparison. [19][9]

Open-ended responses make equivalence harder: two answers may share a conclusion while differing in essential qualifications. Generative aggregation avoids requiring exact groups but introduces another output. Mixture-of-Agents, 2024, supplies earlier responses to an aggregator that writes a new response. That response is neither a vote nor necessarily an existing candidate; it needs its own assessment. Broader communication and coordination choices belong in Multi-Agent Systems. [20]

Checks and their limits

A verifier checks a specified property using available evidence. Its usefulness depends on that property matching the task. False acceptance accepts an unacceptable candidate; false rejection rejects an acceptable one. Both are relative to the intended requirement, which may differ from the implemented check. The general test-oracle problem is deciding what observations justify acceptance. [21]

Lean separates constructing a proof from accepting it. Higher-level proof instructions become a proof term, a formal object checked by a small kernel. An axiom is an assumed statement rather than a proved one. Lean can report which axioms a proof depends on; inconsistent assumptions can undermine what acceptance means. Formal checking is powerful because its acceptance contract is explicit, not because it removes the need to inspect that contract. [22][24]

Executable checks can be too restrictive as well as too permissive. In Benchmarks: The Good, the Bad, and the Ugly, Ali Khial describes tests expecting variable names absent from the instructions or checking internal functions. Such assertions may reject a valid alternative implementation. Conversely, running tests independently cannot repair an expectation that shares the implementation’s mistaken interpretation. [25][21]

Keep checks available during solving distinct from independent final assessment. A solver allowed to optimize against a test has received information from it. For generated code, bound execution with sandbox controls, and protect the evaluator from candidate modifications. For reference-based answers, Retrieval-Augmented Generation develops evidence support; for learned assessors, use judge validation. [26][27]

Selecting the returned answer

Checking supplies information; selection decides what to return. Filtering removes candidates that fail an eligibility condition. Ranking orders those remaining. Best-of-N generates N candidates and returns the highest-scored one. These can compose: reject outputs violating an explicit constraint, then rank eligible answers for usefulness. Weighted aggregation makes a different choice by combining scores across candidates expressing the same answer. [28][29][30]

An outcome scorer assesses a completed solution. A process scorer assesses intermediate steps, whose scores can inform ranking or partial-path search. In Let’s Verify Step by Step, solution ranking multiplied predicted step-correctness probabilities. The generator remained fixed while scorers were evaluated. A numeric score is not automatically a calibrated probability; calibration requires correspondence with observed event frequencies. [31]

The selector can lose an opportunity the generator created. In this invented three-candidate example, A passes the independent task assessment, while B and C fail. The runtime scores are arbitrary ranking values, not probabilities. Remove B from the pool, then add it again: the passing candidate remains available, but the highest-score selection changes.

Hindsight selection uses the independent assessment to recover a passing candidate from the saved pool, if one exists. This diagnostic isolates opportunities lost by the runtime scorer; it does not assume that an equally effective assessment is available at runtime.

Pass@k measures whether at least one of k candidates passes the task’s tests, not whether the selector returns it; its estimator belongs in Evals and Benchmarks. Large Language Monkeys measured this gap: in its MATH experiments, tested selectors plateaued around one hundred samples while further sampling continued exposing solvable problems. [32][18]

Generation and selection must both work. Cobbe and colleagues’ verifier study selected from one hundred solutions per problem, but verification did not consistently help with the smallest training datasets, and improving the generator still mattered. A selector cannot recover a solution absent from its pool. [7]

More candidates can also make selection worse. Scaling Laws for Reward Model Overoptimization found that stronger best-of-N selection could improve a proxy score while reducing a separate reference model’s score. The generator’s weights did not change. The reference was itself a model, not objective truth, but the experiment shows how selection exploits favorable scoring errors. Reassess the selector when the generator, sampling policy, or candidate count changes. [23]

Revision from diagnostic feedback

Independent sampling starts another attempt. Refinement instead retains a candidate and conditions a revision on feedback about it. This can save rediscovering useful work, provided the feedback identifies a genuine defect. Self-Refine, 2023, uses the same language model to generate an answer, produce feedback, and revise it without updating weights. Its published algorithm returns the final revision; it does not independently retain the best verified version. [33]

Self-critique supplies another model judgment, not necessarily new evidence. Large Language Models Cannot Self-Correct Reasoning Yet found correct-to-incorrect revisions in its tested intrinsic-correction settings. Experiments that stop whenever a reference answer declares success give the procedure information ordinary deployment lacks. These are conditional findings, not an impossibility theorem for correction with later models or external feedback. [34]

A concrete counterexample is more diagnostic. The 2006 Combinatorial Sketching for Finite Programs method alternates synthesis and verification: a verifier finds an input violating the specification, and that input constrains the next candidate. Its finite-domain guarantees do not transfer to unrestricted language generation, but the feedback relationship does: name the failed obligation and check the replacement. [35]

# Example contract: absolute value for Python integers.
def candidate_a(x):
    return x

# Catch the expected failure so the replacement checks can run.
try:
    assert candidate_a(-3) == 3
except AssertionError:
    print("candidate_a(-3): expected 3, got -3")

# After diagnosing that failure, propose and check a replacement.
def candidate_b(x):
    return -x if x < 0 else x

for x, expected in [(-3, 3), (0, 0), (3, 3)]:
    assert candidate_b(x) == expected

The negative-input failure points to sign handling; an instruction merely saying “improve the answer” does not. The replacement passes these examples, which remain finite checks rather than exhaustive proof. Because revisions can regress, preserve the best candidate accepted under the chosen checks and replace it only after reassessment. This retention rule is an engineering safeguard, not an automatic property of refinement. [34]

Feedback must also be usable by the revising model. Zhou Yu’s academic literature review describes noisy small-model critiques and cases where a stronger model’s reasoning was incompatible with the smaller model’s correction process. A more capable critic does not by itself guarantee a better revision. [36]

Searching partial solutions

Partial-path search checks unfinished solutions so it can stop spending effort on unproductive paths before completing them. It represents the input and working so far as a state. An expansion proposes one or more continuations, creating alternative states to assess. The procedure can discard a state—pruning—or retain it on the frontier, the collection awaiting further expansion. If the current path disappoints, backtracking returns attention to an earlier alternative. The benefit depends on whether these assessments save more useful work than they consume; the search budget must cover both expansion and checking. [37][38]

Breadth-first exploration examines shallow alternatives before deeper ones; depth-first exploration follows one path before returning to alternatives. Beam search retains a bounded number at each depth. Best-first search expands the highest-priority available state, potentially comparing different depths. Ordering, pruning, and stopping are separate choices. Best-First Beam Search formalizes their relationship under particular score assumptions; those guarantees do not apply automatically to learned reasoning scores. [38]

Tree of Thoughts, introduced by Shunyu Yao and colleagues in 2023, combines a continuation generator, state evaluator, and search procedure. Its twenty-puzzle crossword experiment returned four fully solved puzzles, although hindsight selection from explored states could recover seven. An evaluator sometimes rejected a valid unfamiliar word. Exploring a useful state did not ensure retaining or returning it. [37][39]

A small published constraint puzzle makes frontier management concrete. Alice, Bob, and Carol occupy different red, green, and blue houses. Alice is not in red; Bob is not in green; Carol is in neither red nor green. The constructed search keeps alternatives explicit before completing an assignment. [40]

Carol must occupy blue, so assigning blue to Alice creates a contradiction before Bob is assigned anything. This rejection follows from the constraints, unlike judging an unfamiliar crossword word unlikely. The general design choice is where to check: tiny steps add checking overhead, while large steps postpone feedback. A likely text continuation is not necessarily a promising solution. This searches possible solutions, not documents; choosing actions with external effects adds the responsibilities of Agent Engineering. [37][40]

Learning from trial continuations

Sometimes a partial state’s promise becomes clearer only after exploring what could follow it. Monte Carlo Tree Search, or MCTS, allocates repeated trials among branches. It selects a path, expands a state, evaluates downstream prospects through a trial continuation—a rollout—or a learned value estimate, and backs up the result through visited ancestors. These statistics guide later exploration; updating them does not update model weights. [41][42]

The 2006 UCT method, short for Upper Confidence Bounds Applied to Trees, balances exploitation, spending work on branches with promising estimated returns, against exploration, investigating less-visited alternatives. A successful rollout raises evidence for its visited path, while uncertainty can still justify trying another branch. The rule depends on meaningful simulations and rewards; a language-model continuation is not automatically an accurate simulation. The bookkeeping tracks a visit count N and an accumulated return W at each visited node; its mean estimate is W/N. [41]

AlphaGo, described by David Silver, Aja Huang, and colleagues in 2016, combined learned move guidance with tree search, value estimates, and fast simulated play. Its component experiments found the combination of value estimates and simulated outcomes stronger than either alone. The contribution was a division of responsibility: learned models proposed and evaluated, while search investigated the current position. Go’s exact legal moves and outcomes made that evaluation setting much more constrained than general language tasks. [42][43]

That distinction matters for transfer. DeepSeek-AI’s January 2025 DeepSeek-R1 report described an unsuccessful attempt to obtain iterative training improvements through MCTS, citing language generation’s branching space and unreliable fine-grained value estimates. This was not the serving procedure establishing R1’s main results, nor proof that inference-time search generally fails. It shows why additional search machinery needs its own justification. Independent sampling or bounded beam search remains a credible baseline when branch evaluation is weak. [44]

Where additional work helps

The value of another computation depends on the limitation it can change. If useful solutions appear among independent attempts, additional sampling may improve coverage. If a mostly useful solution has a localized, checkable defect, revision can target it. If good candidates already exist but are rejected, additional generation addresses the wrong bottleneck. Executable performance objectives make this distinction practical: Coding Evals: From Code Snippets to Codebases describes repeated optimization against tests, while also noting reward-hacking cases. [3][45]

Difficulty does not determine the best allocation by itself. In Snell and colleagues’ 2024 study, some easy MATH problems became less accurate under stronger search, consistent with exploiting verifier errors; the hardest bin showed little progress under the tested methods. A larger budget helps only where the available mechanism can use it. [30]

Even extending one trace changes more than its length. The January 2025 s1 study held its trained model fixed while intervening in termination and continuation. On MATH500, doubling thinking without an added cue reduced accuracy from 93.0% to 90.2%; extension with a Wait cue reached 93.0%. Duration and continuation conditions changed together. More generated working was not a universal improvement. [46]

Some limitations require an observation, not more calculation. Suppose an input asks whether a particular shipment has arrived but contains no delivery record. The same input is compatible with arrival and non-arrival. Computation on that input alone cannot determine which external event occurred. Search and retrieval can acquire information; an internal continuation can only reason from information already available. Open-ended tasks create another difficulty: if no decisive acceptance criterion exists, more elaborate selection may optimize a preference proxy rather than resolve correctness. [21][47]

Count work, charges, and time

A reasoning budget must cover the complete procedure: processing inputs, generating every candidate, inspecting rejected paths, scoring, running executable checks, revising, choosing further work, and producing the final response. A cheap-looking individual call can become an expensive request when repeated throughout a workflow. Keep three ledgers separate: computational work, monetary charges, and elapsed time. [48]

The critical path is the longest dependency path determining earliest completion under specified operation durations and available resources. Consider two independent candidate generations taking three seconds each, followed by a one-second check-and-select operation that needs both. Serial execution takes seven seconds; concurrent generation takes four. Both perform seven operation-seconds of leaf work, a duration-based accounting proxy rather than a hardware-compute measurement. [49]

In a real service, concurrency can introduce contention and waiting. Measure request-to-delivery latency separately from response onset and internal execution intervals. A policy waiting for every candidate can be delayed by its slowest required attempt even when most finish quickly. Latency boundaries explain the measurements; serving explains execution. Token counts are useful within an identified configuration, not a universal unit equating different models, input lengths, or hardware. [50][49]

Configured effort is not realized usage. The August 2026 Gemini documentation distinguishes thinking levels from numerical budgets and notes that a budget may be exceeded or undershot. It reports thought tokens separately from candidate output. The inspected OpenAI documentation likewise reports reasoning usage separately even though those tokens consume output allowance and are billed. These interfaces have model-specific semantics; their controls are not interchangeable. [15][51]

Allocation overhead belongs in the ledger too. Snell and colleagues estimated difficulty using 2,048 sampled answers per question, with correctness or averaged verifier scores supplying the estimate. Their reported compute comparisons excluded that estimation cost. Predicted difficulty therefore did not make the allocation overhead free or establish fully costed deployment savings. [52]

For an operational comparison, record actual usage and charges for completed, rejected, failed, and interrupted work. Broader pricing and capacity decisions belong in AI Cost and Performance Engineering. Here, their purpose is to make the reasoning policy’s tradeoff visible rather than attributing its entire cost to the final answer. [48]

Allocate the next computation

Metareasoning means choosing computations themselves. The 1989 rational-metareasoning account treats additional search as valuable when it improves the eventual decision enough to justify its cost and delay. A simplified engineering restatement is: [53]

Here, $c$ is a proposed computation, $a_0$ the decision available now, and $a_c$ the decision selected after seeing its result. Utility, $U$, assigns a numerical value to how desirable a decision is for the task. The expectation $\mathbb{E}$ averages over the computation’s possible results: would any of them change the decision for the better? Subtract resource and delay cost $C(c)$, expressed in the same units. A positive value favors continuing when feasible. Estimating this benefit also costs work, and looking only one computation ahead can miss work that enables a valuable later step. The equation expresses a decision principle, not an exact universal controller. [53]

A fixed budget gives every request the same allowance. A difficulty-conditioned policy assigns allowances using an estimate made before substantial solving. An online policy reacts as observations arrive: candidate disagreement, failed checks, or improvement across revisions. These observations are informative only through a tested relationship to useful outcomes. Disagreement might indicate productive diversity, ambiguity, or several different mistakes. [54][55]

ThoughtTerminator, proposed by Xiao Pu and colleagues in April 2025, illustrates a bounded adaptive method: estimate difficulty, assign a reasoning deadline, encourage completion, and detect answer formatting. Its reductions in overthinking measures included accuracy regressions. Formatting is observable, but not correctness. Such methods need complete accounting and task-quality evaluation before their smaller token totals become a savings claim. [57]

Nathan Lambert’s taxonomy talk identifies wasted effort on easy requests as a practical obstacle. Solving it requires more than exposing a user-facing effort selector: the allocation policy must predict where work helps. Choosing a different model or provider is an adjacent decision owned by Model Routing and LLM Gateways. [54]

Stop with a meaningful result

A stopping rule ends additional reasoning work. An incumbent is the candidate currently retained for possible return. Stopping can mean the incumbent satisfies the required checks, that further work is not worthwhile, or simply that resources have run out. Those conditions must not share an undifferentiated success status. [6][58]

Adaptive-consistency, 2023, updates answer counts and stops when its statistical criterion sufficiently favors the leading answer, subject to a maximum sample budget. Its confidence concerns the most probable sampled answer, not truth. In aggregate GPT-3.5 reasoning experiments, fixed forty-response sampling achieved 76.4% accuracy; adaptive sampling averaged ten responses with 76.2%. Those counts are neither token work nor wall-clock time, and concentrated mistakes can still produce confident agreement. [59]

Solver interfaces make the difference explicit. OR-Tools CP-SAT distinguishes a feasible solution, proven optimality, proven infeasibility, an invalid model, and an unknown result. These statuses concern its encoded constraints. A language-model search cannot borrow their guarantees merely by using the same names; failure to find a solution before a limit does not prove none exists. [58]

Reserve resources for final checking and delivery. Ending thought generation still requires constructing the answer. OpenAI’s documented output limit includes reasoning and other output tokens; exhaustion can produce an incomplete response before any visible answer. A deadline policy should stop launching work that would prevent required checking and delivery of an existing incumbent. In the schedule, a checked incumbent I remains available while a ready candidate X and an optional new candidate Y compete for one checker. Fixed durations and negligible overhead isolate work order. A replacement must pass the behavior check and run faster on the fixed test workload. [51][57]

Abstention means declining automatic completion when no acceptable result is available. Evaluate it as a policy: measure both how often the system answers and error among accepted answers, as explained in deferral evaluation. Self-reported confidence is only useful when its meaning and calibration have been established for the relevant event. [60]

Measure the answer-producing policy

Define the decision before running the comparison: improve returned-answer quality within a budget, reduce expense at a required quality level, or meet a delivery deadline without unacceptable regressions. An evaluation case specifies the input, available information, initial state, and success criteria; a trial is one execution. Repeated trials reveal variability. Preserve their outputs and reset relevant state so one attempt does not silently assist another. [61]

Compare plausible policies, not every named technique. An immediate answer and a deliberative answer establish a basic baseline. Add sampling with aggregation when final answers can be compared, verifier selection when checking is meaningful, refinement when feedback is diagnostic, and partial-path search when unfinished states can be evaluated. Hold the model, task information, and assessment fixed when isolating inference policy; explicitly identify any other changed ingredient. [62][29]

Use the same held-out tasks across policies, keep repeated attempts grouped by their originating task, and inspect consequential disagreements. Matched comparisons and attempt-policy metrics provide the statistical details. Assess the answer actually returned. Hindsight selection using unavailable correctness labels measures an opportunity, not the deployed selector. [61][18]

OpenAI’s 2024 o1 report illustrates why a model score is incomplete without its answer policy. On AIME 2024, it reported 74% accuracy from one sample, 83% from consensus over 64 samples, and 93% from learned reranking of 1,000 samples. These used unequal generation and selection budgets, with no complete cost-matched comparison. They are three procedures, not interchangeable descriptions of one response. [10]

Equal-budget comparisons identify which procedure uses a specified allowance more effectively. Equal-quality comparisons identify the least expensive procedure meeting a required outcome level. Neither can be replaced by observing that successful responses were longer: task difficulty affects both reasoning length and success. Change the effort policy on matched inputs to investigate its effect. [46][62]

Choose the simplest policy that meets the task’s quality and delivery requirements. Extra computation earns its place when the improvement survives candidate selection, final checking, stopping, and full accounting. The relevant outcome is not how much the system thought or how impressive its best discarded attempt was, but what it reliably delivered.

Open questions

1. 01

   Fully costed adaptive allocation remains difficult because estimating difficulty and deciding what to check can themselves consume substantial work. Progress would demonstrate held-out returned-answer gains after charging for the controller, every candidate, verification, and deadline misses. [52][57]

2. 02

   Selectors must remain reliable as search changes the candidates they encounter. Better performance on ordinary responses may not survive stronger selection pressure. Progress would preserve independently assessed answer quality as candidate counts and search strategies change, rather than merely increasing runtime scores. [23]

3. 03

   Reliable partial-state evaluation is a bottleneck for language-based search: unfinished arguments can look unpromising precisely because they take unfamiliar but valid routes. Progress would reduce premature pruning without spending so much on evaluation that complete sampling becomes preferable. [39][44]

4. 04

   Safe interruption requires more than detecting answer-like formatting. A useful stopping policy must preserve an eligible incumbent, reserve time to deliver it, and recognize when abstention is preferable. Progress would reduce resource use while maintaining task-specific accepted-answer quality and completion rates. [57][51]