Overthinking Loops in AI Reasoning

• Overthinking loops are recurrent failure modes in neural and language-model inference marked by redundant reasoning steps after a correct solution is reached.
• They manifest in chain-of-thought tasks, deep networks, and tool-using agents through repetitive verification, self-questioning, and overwritten outputs.
• Mitigation techniques such as batch prompting, early stopping, and budget calibration have shown practical success in reducing redundant computations and improving efficiency.

Searching arXiv for papers on overthinking loops and related mitigation methods. Overthinking loops are recurrent failure modes in neural and language-model inference in which useful progress has saturated but computation continues. In multi-step chain-of-thought reasoning, an overthinking loop can denote a recurring pattern where the model “hedges,” self-questions, or self-corrects without making forward progress, or a regime in which the model continues generating additional reasoning tokens even after it has already produced a correct solution (Qiu et al., 6 Nov 2025, Wang et al., 23 Mar 2026). Closely related formulations appear in deep neural networks as wasteful and destructive overthinking (Kaya et al., 2018), in tool reasoning as overwrite-after-correctness (Oh et al., 1 Oct 2025), and in tool-using agents as cyclic multi-tool trajectories whose cost inflation is structural rather than merely token-level (Lee et al., 16 Feb 2026).

1. Definitions and scope

Across the cited literature, “overthinking loops” covers several related but non-identical phenomena. In large reasoning models, the central pattern is redundant continuation: repeated verification, re-derivations, backtracking, or hedging after the decisive reasoning has already occurred (Wang et al., 23 Mar 2026). In batch-prompting work, an overthinking loop is defined at the chain-of-thought level as a recurring pattern where the model “hedges,” self-questions, or self-corrects without making forward progress toward the answer (Qiu et al., 6 Nov 2025). In tool-use, the definition shifts from token redundancy to action overwrite: an output trajectory exhibits overthinking if there exists some step $t'$ at which the model’s output corresponds to a correct function call $f^*(x)$, but the final decoded call is incorrect (Oh et al., 1 Oct 2025). In agentic settings, structural overthinking arises when multiple individually benign tool calls compose into a loop, so that no single call appears abnormal even though the overall trajectory becomes cyclic (Lee et al., 16 Feb 2026).

The deep-learning precursor is the distinction between wasteful and destructive overthinking. In a Shallow-Deep Network, wasteful overthinking occurs whenever the network has already “got the right answer” at some internal classifier but keeps computing to the end, while destructive overthinking occurs when an internal classifier is correct but the final prediction is wrong (Kaya et al., 2018). This vocabulary remains useful for later LLM work because several LLM papers similarly distinguish harmless verbosity from correctness-reversing post-solution continuation.

Setting	Definition in the literature	Typical manifestation
CoT reasoning	Hedging, self-questioning, or self-correction without forward progress	Repetitive “wait,” retracing, re-verification
Post-solution continuation	Extra reasoning after the first correct solution	Redundant verification or answer drift
Tool reasoning	Correct intermediate tool call overwritten later	Incorrect final function call
Tool-using agents	Cyclic tool-call trajectory	Repetition, forced refinement, distraction
Deep networks	Correct shallow prediction overridden deeper	Wasteful or destructive overthinking

A common misconception is that overthinking is identical to long outputs. The agentic setting makes this false in a precise sense: structural overthinking can produce severe resource amplification even when no individual step is verbose (Lee et al., 16 Feb 2026). Conversely, some work defines overthinking by utility rather than length, treating extra reasoning as problematic only once marginal gains have vanished (Zhang et al., 9 Oct 2025).

2. Mechanisms and thought structures

Several causal accounts recur. ROM attributes overthinking to three factors: multi-solution generation, lack of stopping signal, and self-correction bias. Distilled chain-of-thought demonstrations often contain several “solution attempts” in one trajectory; standard autoregressive decoding lacks a built-in mechanism to recognize that a correct answer has been reached; and models trained to self-correct may re-examine an already correct answer as though it were tentative (Wang et al., 23 Mar 2026). These mechanisms jointly explain why redundant continuation can increase latency and compute cost and can also induce answer drift.

A complementary stage-based account divides reasoning into an insufficient exploration stage, a compensatory reasoning stage, and a reasoning convergence stage. In this view, correct answers typically emerge in the compensatory reasoning stage, whereas reasoning convergence often triggers overthinking, causing increased resource usage or even infinite loops. The key control target is therefore the end of the compensatory reasoning stage, defined as the Reasoning Completion Point (RCP) (Wei et al., 25 Aug 2025). This formulation reframes the problem as identifying when the first complete reasoning cycle has finished.

TRACE provides a finer structural description by decomposing traces into minimally complete sub-thoughts and then constructing thought-progression graphs. Two dominant motifs are reported for open-weight thinking models: Explorer and Late Landing. Explorer traces contain multiple distinct answers with repeated branching and backtrack loops; Late Landing traces are mostly linear until convergence, after which they accumulate many redundant self-verification self-loops. The reported interpretation is that over-verification and over-exploration are the primary drivers of overthinking in LLMs (Zhang et al., 9 Oct 2025).

The temperature study isolates a training-distribution explanation. It defines “errors in learning” as deviations between the learned next-token distribution $P_\theta(x_t \mid x_{<t})$ and the teacher distribution $P_{\mathrm{train}}(x_t \mid x_{<t})$. Two mechanisms then produce loops: risk aversion caused by hardness of learning, in which an easy cyclic action keeps higher probability than any one hard progress-making action, and a Transformer inductive bias toward temporally correlated errors, so that the same mistaken action is repeatedly preferred on successive revisits (Pipis et al., 15 Dec 2025). Higher temperature reduces looping by promoting exploration, but the paper explicitly describes temperature as a stopgap rather than a holistic solution.

This body of work suggests that overthinking is not a single pathology. Some loops arise after correctness has already been achieved; some arise before convergence because the model repeatedly avoids difficult progress-making moves; and some arise from graph-level reuse of previously visited answer states or tool states.

3. Metrics and formal criteria

The measurement literature has moved beyond raw token count. For batch-prompted reasoning, three token-level metrics are defined over the reasoning sequence $R(q) = [s_1, s_2, \dots, s_n]$. The hedging score is the fraction of tokens belonging to a predefined hedge set $\mathcal H$,

$$H(q) = \frac{|\{ t \in R(q) : t \in \mathcal H \}|}{|R(q)|}.$$

The loop frequency is the number of detected “hedge $\to$ retrace” segments divided by the total number of reasoning steps,

$L(q) = \frac{k}{|R(q)|}.$

The self-correction rate is the fraction of tokens that match explicit self-correction markers,

$$R_{\mathrm{corr}}(q) = \frac{|\{ t \in R(q) : t \in \mathcal C \}|}{|R(q)|}.$$

An overthinking loop is present when $f^*(x)$0, $f^*(x)$1, or $f^*(x)$2 exceed task-dependent thresholds, with examples $f^*(x)$3 or $f^*(x)$4 in the reported experiments (Qiu et al., 6 Nov 2025).

A second line of work anchors the analysis at the first correct solution (FCS). “Reconsidering Overthinking” decomposes redundancy into internal redundancy, meaning low-contribution reasoning steps within the FCS, and external redundancy, meaning unnecessary continuation after the FCS. Internal Redundancy Degree (IRD) is defined by embedding sliding windows over FCS sentences and averaging clipped adjacent-window cosine similarities; External Redundancy Degree (ERD) is the ratio $f^*(x)$5 (Hong et al., 4 Aug 2025). This decomposition is important because the paper reports that external redundancy can be safely removed without degrading performance, whereas internal redundancy must be reduced more cautiously.

Utility-based definitions replace token length by marginal return. TRACE defines $f^*(x)$6 as the model’s accuracy, or probability of correct, if stopped after $f^*(x)$7 sub-thoughts, and the marginal return as $f^*(x)$8. The convergence point $f^*(x)$9 is the smallest $P_\theta(x_t \mid x_{<t})$0 such that $P_\theta(x_t \mid x_{<t})$1, and any reasoning beyond $P_\theta(x_t \mid x_{<t})$2 is classified as overthinking (Zhang et al., 9 Oct 2025). This criterion makes explicit that not every extra token is harmful; the problem begins when extra structure adds negligible utility.

Entropy-based control introduces a different observable. CER defines token entropy

$P_\theta(x_t \mid x_{<t})$3

and the Token Entropy Cumulative Average

$P_\theta(x_t \mid x_{<t})$4

The empirical claim is that short-CoT models show a TECA curve that spikes briefly and then drops, whereas overthinking models’ TECA continues rising (Jiang et al., 2 Oct 2025). In this framework, overthinking is identified with prolonged exploration rather than merely long output.

Benchmarking work formalizes the accuracy-efficiency tradeoff by defining an Overthinking Score as the harmonic mean of task accuracy $P_\theta(x_t \mid x_{<t})$5 and normalized token-efficiency $P_\theta(x_t \mid x_{<t})$6:

$P_\theta(x_t \mid x_{<t})$7

This makes overthinking measurable even on simple arithmetic tasks, where some reasoning-enhanced models produce thousands of tokens with lower accuracy than more concise models (Srivastava et al., 5 Jul 2025).

4. Mitigation during inference and decoding

Inference-time mitigation spans batching, early exit, thresholding, and budget calibration. Batch prompting groups $P_\theta(x_t \mid x_{<t})$8 inputs into one joint prompt, amortizes a fixed instruction overhead $P_\theta(x_t \mid x_{<t})$9, and changes the reasoning regime by forcing the model to “spread” computational effort across the batch. On OpenAI-o1 across 13 benchmarks, the reported averages are: at batch size $P_{\mathrm{train}}(x_t \mid x_{<t})$0, accuracy $P_{\mathrm{train}}(x_t \mid x_{<t})$1, reasoning tokens $P_{\mathrm{train}}(x_t \mid x_{<t})$2, $P_{\mathrm{train}}(x_t \mid x_{<t})$3, $P_{\mathrm{train}}(x_t \mid x_{<t})$4, and $P_{\mathrm{train}}(x_t \mid x_{<t})$5; at $P_{\mathrm{train}}(x_t \mid x_{<t})$6, accuracy $P_{\mathrm{train}}(x_t \mid x_{<t})$7, reasoning tokens $P_{\mathrm{train}}(x_t \mid x_{<t})$8, $P_{\mathrm{train}}(x_t \mid x_{<t})$9, $R(q) = [s_1, s_2, \dots, s_n]$0, and $R(q) = [s_1, s_2, \dots, s_n]$1. The accompanying summary states that reasoning tokens drop by $R(q) = [s_1, s_2, \dots, s_n]$2 and that hedging score $R(q) = [s_1, s_2, \dots, s_n]$3 and loop frequency $R(q) = [s_1, s_2, \dots, s_n]$4 shrink by more than $R(q) = [s_1, s_2, \dots, s_n]$5 (Qiu et al., 6 Nov 2025). The recommended operating range is batch size $R(q) = [s_1, s_2, \dots, s_n]$6, with uniformity within a batch to maximize pattern induction.

Streaming detectors perform token-level intervention in real time. ROM attaches a lightweight detection head to late-layer hidden states of a frozen backbone, computes

$R(q) = [s_1, s_2, \dots, s_n]$7

and triggers intervention once $R(q) = [s_1, s_2, \dots, s_n]$8 exceeds a threshold, with default $R(q) = [s_1, s_2, \dots, s_n]$9. The reported overall averages across seven benchmarks are: Vanilla, Acc $\mathcal H$0, SL $\mathcal H$1, SE $\mathcal H$2; L1, Acc $\mathcal H$3, SL $\mathcal H$4, SE $\mathcal H$5; EAT, Acc $\mathcal H$6, SL $\mathcal H$7, SE $\mathcal H$8; and $\mathcal H$9, Acc $$H(q) = \frac{|\{ t \in R(q) : t \in \mathcal H \}|}{|R(q)|}.$$0, SL $$H(q) = \frac{|\{ t \in R(q) : t \in \mathcal H \}|}{|R(q)|}.$$1, SE $$H(q) = \frac{|\{ t \in R(q) : t \in \mathcal H \}|}{|R(q)|}.$$2. Relative to Vanilla, ROM reduces response length by $$H(q) = \frac{|\{ t \in R(q) : t \in \mathcal H \}|}{|R(q)|}.$$3 and improves efficiency by $$H(q) = \frac{|\{ t \in R(q) : t \in \mathcal H \}|}{|R(q)|}.$$4 (Wang et al., 23 Mar 2026). The design emphasis is instance-adaptive truncation at a safe boundary, followed by a short final-answer cue.

Several methods use explicit end-of-thinking signals. RCPD monitors the rank of the token </think> in the vocabulary distribution and distills the discovered patterns into four heuristic stopping rules, including stopping when $$H(q) = \frac{|\{ t \in R(q) : t \in \mathcal H \}|}{|R(q)|}.$$5, when recent ranks satisfy a staged threshold pattern, or when a short history stays within a narrow rank band (Wei et al., 25 Aug 2025). ThinkBrake uses the log-probability margin between </think> and the current top token at sentence boundaries,

$$H(q) = \frac{|\{ t \in R(q) : t \in \mathcal H \}|}{|R(q)|}.$$6

and forces </think> when the margin falls below $$H(q) = \frac{|\{ t \in R(q) : t \in \mathcal H \}|}{|R(q)|}.$$7. On BFCL non-live, the reported averages are Base $$H(q) = \frac{|\{ t \in R(q) : t \in \mathcal H \}|}{|R(q)|}.$$8 accuracy and ThinkBrake $$H(q) = \frac{|\{ t \in R(q) : t \in \mathcal H \}|}{|R(q)|}.$$9 with token reduction $\to$0; on BFCL live, Base $\to$1 and ThinkBrake $\to$2 with token reduction $\to$3 (Oh et al., 1 Oct 2025).

Budget-calibrated decoding addresses overthinking as misallocation of compute. THOUGHTTERMINATOR estimates question difficulty, maps it to a token budget $\to$4, inserts periodic reminders, checks for final-answer markers, and if necessary issues the terminator prompt “Out of time, finalize your answer now.” The reported effect is that local $\to$5 drops by $\to$6–$\to$7 and global $\to$8 by $\to$9–$L(q) = \frac{k}{|R(q)|}.$0 across five reasoning models, while preserving or improving accuracy in most settings; for DeepSeek-R1-1.5B on MATH500, tokens drop from $L(q) = \frac{k}{|R(q)|}.$1 to $L(q) = \frac{k}{|R(q)|}.$2 and Pass@10 rises from $L(q) = \frac{k}{|R(q)|}.$3 to $L(q) = \frac{k}{|R(q)|}.$4 (Pu et al., 17 Apr 2025).

These methods differ in observability. Some rely on surface markers, some on hidden states, some on batch structure, and some on external difficulty prediction. The shared principle is early transition from exploratory reasoning to answer emission once evidence of convergence becomes strong enough.

5. Training-time, architectural, and representation-level control

Training-time work increasingly separates what can be pruned safely from what remains necessary for correctness. The dual-penalty RL framework in “Reconsidering Overthinking” assigns zero reward to traces with wrong final answers, but for correct traces multiplies an internal penalty $L(q) = \frac{k}{|R(q)|}.$5 derived from IRD by an external penalty $L(q) = \frac{k}{|R(q)|}.$6. The reported training dynamics show ERD converging near $L(q) = \frac{k}{|R(q)|}.$7 and IRD near $L(q) = \frac{k}{|R(q)|}.$8, with token reductions of $L(q) = \frac{k}{|R(q)|}.$9–$$R_{\mathrm{corr}}(q) = \frac{|\{ t \in R(q) : t \in \mathcal C \}|}{|R(q)|}.$$0 and less than $$R_{\mathrm{corr}}(q) = \frac{|\{ t \in R(q) : t \in \mathcal C \}|}{|R(q)|}.$$1–$$R_{\mathrm{corr}}(q) = \frac{|\{ t \in R(q) : t \in \mathcal C \}|}{|R(q)|}.$$2 accuracy drop in nearly all settings. The paper’s strongest qualitative conclusion is that external-only training can drive ERD to $$R_{\mathrm{corr}}(q) = \frac{|\{ t \in R(q) : t \in \mathcal C \}|}{|R(q)|}.$$3 with essentially zero accuracy loss on GSM8K, MATH500, and AIME24, while internal-only training can incur substantial accuracy drops, especially on AIME24 (Hong et al., 4 Aug 2025).

Self-Braking Tuning moves the stopping policy into the model’s own output behavior. It defines a Reasoning Efficiency Ratio $$R_{\mathrm{corr}}(q) = \frac{|\{ t \in R(q) : t \in \mathcal C \}|}{|R(q)|}.$$4, an Overthinking Marker Ratio

$$R_{\mathrm{corr}}(q) = \frac{|\{ t \in R(q) : t \in \mathcal C \}|}{|R(q)|}.$$5

and a composite Overthink Score

$$R_{\mathrm{corr}}(q) = \frac{|\{ t \in R(q) : t \in \mathcal C \}|}{|R(q)|}.$$6

with $$R_{\mathrm{corr}}(q) = \frac{|\{ t \in R(q) : t \in \mathcal C \}|}{|R(q)|}.$$7. The model is then fine-tuned on truncated trajectories plus a natural-language braking prompt such as “Wait, I’ve gotten the same answer twice. That should be enough reasoning—let me proceed to the final answer.” Reported averages include Qwen2.5-Math-1.5B-Instruct baseline $$R_{\mathrm{corr}}(q) = \frac{|\{ t \in R(q) : t \in \mathcal C \}|}{|R(q)|}.$$8 accuracy and $$R_{\mathrm{corr}}(q) = \frac{|\{ t \in R(q) : t \in \mathcal C \}|}{|R(q)|}.$$9 tokens, SBT-E $f^*(x)$00 and $f^*(x)$01, and SBT-D $f^*(x)$02 and $f^*(x)$03; for Llama-3.1-8B-Instruct, baseline $f^*(x)$04 and $f^*(x)$05, SBT-E $f^*(x)$06 and $f^*(x)$07, and SBT-D $f^*(x)$08 and $f^*(x)$09 (Zhao et al., 20 May 2025). The summary states that SBT cuts inference token use by up to $f^*(x)$10 while maintaining comparable accuracy.

CER integrates entropy control into GRPO. Its segmented reward uses $f^*(x)$11 for correctness and

$f^*(x)$12

as a penalty for high cumulative uncertainty. On Qwen3-4B, the reported effect is a $f^*(x)$13 length reduction on GSM8K, from $f^*(x)$14 tokens to $f^*(x)$15, with accuracy rising from $f^*(x)$16 to $f^*(x)$17; on Qwen3-8B, CER reports a $f^*(x)$18 cut on GSM8K and $f^*(x)$19 on MATH500 with no accuracy loss (Jiang et al., 2 Oct 2025).

Mechanistic and architectural work extends the picture beyond explicit CoT. Manifold Steering reports that overthinking can be captured by a single direction in activation space, but that performance plateaus or deteriorates when intervention strength increases because the phenomenon is tied to a low-dimensional manifold rather than a single noisy direction. The reported outcome is token reduction by up to $f^*(x)$20 while maintaining or improving accuracy on several mathematical benchmarks, with $f^*(x)$21–$f^*(x)$22 token reductions on LiveCodeBench and $f^*(x)$23–$f^*(x)$24 on GPQA-Diamond without retraining (Huang et al., 28 May 2025). In recurrent deep-thinking models for vision, “Learning to Stop Overthinking at Test Time” instead uses a self-supervised auxiliary task at test time to select the iteration $f^*(x)$25 that maximizes auxiliary accuracy, thereby matching per-sample difficulty without an explicit ponder-cost term (Bao et al., 16 Feb 2025). In adaptive-loop transformers, looping and memory are treated as model capacities rather than failure modes: looping primarily benefits mathematical reasoning, memory banks help recover commonsense performance, and later layers learn to loop more heavily than early layers (Frey et al., 9 Mar 2026). This suggests that “loop” is not inherently pathological; pathology begins when iteration continues after its marginal contribution has decayed.

6. Adversarial induction, structural risk, and open questions

Overthinking can be induced, not merely observed. POT, or Prompt-Only OverThinking, is described as a black-box attack framework that uses LLM-based iterative optimization to generate covert and semantically natural adversarial prompts, while eliminating dependence on external data access and model retrieval (Li et al., 23 Aug 2025). Because the available description does not include the paper’s technical details, only the high-level claim is established here: overthinking itself can be an attack target.

The agentic variant is more fully specified. “Overthinking Loops in Agents” formalizes a mixed registry

$f^*(x)$26

a tool-call trajectory $f^*(x)$27, and token amplification

$f^*(x)$28

The reported attacks implement 14 malicious tools across three servers and trigger repetition, forced refinement, and distraction. In the ReAct setting, token amplification reaches $f^*(x)$29; in Qwen-Code, the average amplification ranges from $f^*(x)$30 to $f^*(x)$31, with runtime increases up to $f^*(x)$32 and per-problem extremes of $f^*(x)$33 token amplification and $f^*(x)$34 runtime (Lee et al., 16 Feb 2026). The paper also reports that NoWait, a decoding-time concision control, does not prevent this structural loop induction, with mixed-registry runs still exhibiting $f^*(x)$35–$f^*(x)$36 token amplification.

The earlier SDN literature shows a closely related destructive effect in image models. Overthinking is pervasive: on CIFAR-10, $f^*(x)$37 of test samples reach a correct internal classifier before the final layer, and up to $f^*(x)$38 of final misclassifications are cases where some internal classifier was correct before being overturned. Under a BadNets backdoor on CIFAR-10, a converted SDN reports early internal correctness on about $f^*(x)$39 of backdoor samples, while early exits at $f^*(x)$40 restore correct classification on about $f^*(x)$41 of backdoor inputs and reduce attack success from $f^*(x)$42 to about $f^*(x)$43 (Kaya et al., 2018). This is not a language-model result, but it establishes a broader computational pattern: later computation can both waste resources and overwrite already-correct decisions.

Several open questions remain explicit in the cited work. Batch prompting notes missing ablations on instruction wording and batch composition and asks whether batching can be combined with lightweight budget control (Qiu et al., 6 Nov 2025). ROM notes dependence on a strong external verifier for token-level labels and unclear data-scaling behavior beyond a relatively small dataset (Wang et al., 23 Mar 2026). The temperature study argues that reducing looping requires improving the learned distribution itself through targeted augmentation, curriculum, architectural refinements, or explicit regularizers, because sampling temperature alone does not erase the underlying errors in learning (Pipis et al., 15 Dec 2025). Taken together, these results support a broad conclusion: overthinking loops are best understood as failures of calibration, halting, and trajectory structure, and not simply as long outputs.