sCoT: Self-Calling Chain-of-Thought

Updated 5 July 2026

Self-Calling Chain-of-Thought (sCoT) is a recursive reasoning method where a language model re-invokes its own intermediate artifacts to critique and refine its outputs.
The approach employs various architectures—such as double-pass reflection, step-selective repair, and subagent decomposition—to enhance error correction and adaptive depth control.
sCoT emphasizes self-evaluation, iterative improvement, and dynamic routing based on risk assessment, leading to more reliable and efficient inference.

Self-Calling Chain-of-Thought (sCoT) denotes an inference-time reasoning regime in which a LLM re-invokes itself on its own intermediate artifacts—reasoning traces, candidate thoughts, subproblems, or verification targets—so that model outputs become inputs to subsequent reasoning steps. In the recent literature, this idea appears both as prompt-level self-reflection, such as double-pass critique-and-refine pipelines, and as explicit agentic architectures in which a main model delegates atomic subtasks to parameter-sharing replicas operating in isolated contexts (Ji et al., 20 Jan 2025, Yang et al., 9 Dec 2025). Across these formulations, sCoT is characterized by recursive decomposition, self-evaluation, selective correction, and a controller—explicit or implicit—that determines when additional reasoning passes are beneficial.

1. Definitions and conceptual scope

A minimal formalization of sCoT is the two-call pattern

$\text{CoT}_1 = f_\theta(x), \qquad \text{CoT}_2 = f_\theta(x,\text{CoT}_1;\text{“reflect”}),$

where the second call is conditioned on the first and is instructed to review, critique, and refine it. "MyGO Multiplex CoT" describes exactly this structure as a double Chain-of-Thought method: the model first generates a normal Chain of Thought, then generates a second Chain of Thought that explicitly reviews, critiques, and refines the first, with the final answer derived from the refined pass (Ji et al., 20 Jan 2025). In that sense, the defining property of sCoT is not merely multi-step reasoning, but recursive reuse of self-produced intermediate state.

The concept broadens when the intermediate artifact is not a textual rationale but a subtask interface. "Thinking with Images via Self-Calling Agent" defines Self-Calling Chain-of-Thought explicitly as a visual reasoning paradigm in which a main agent decomposes a complex visual reasoning task into atomic subtasks and invokes parameter-sharing subagents to solve them in isolated context (Yang et al., 9 Dec 2025). Here, the self-call is operational rather than rhetorical: the model delegates perception-bound subtasks to virtual replicas of itself and incorporates their textual results into the main chain.

A recurring conceptual theme is that sCoT treats intermediate reasoning as a first-class computational object. "Rethinking Chain-of-Thought from the Perspective of Self-Training" frames CoT and self-training as sharing the objective of iteratively leveraging model-generated information to progressively reduce prediction uncertainty, and proposes a framework with a task-specific prompt module and an adaptive reasoning iteration module (Wu et al., 2024). This suggests a broader interpretation of sCoT as inference-time self-training: the model repeatedly conditions on its own pseudo-labels, rationales, or control signals.

2. Architectural patterns

Several distinct architectures instantiate self-calling behavior.

Pattern	Representative method	Core mechanism
Double-pass reflection	Multiplex CoT	CoT $_1$ then CoT $_2$ critique-and-refine
Step-selective repair	ASCoT	Risk-based verification and local correction
Search over intermediate thoughts	C-ToT	Pairwise comparison among candidate thoughts
Main-agent/subagent decomposition	Self-Calling Agent	Parameter-sharing subagents for atomic subtasks

In Multiplex CoT, the model can be run either in a single prompt with "First… Then…" instructions or as two serial API calls, one producing initial reasoning and the next consuming that reasoning to critique it. The paper emphasizes three self-reflective properties: taking its own output as input, explicit critique and verification, and iterative improvement, while noting that additional rounds beyond the first two exhibit diminishing returns (Ji et al., 20 Jan 2025).

ASCoT implements a more granular pattern. It generates a full CoT, identifies high-risk steps, and only then re-calls the model on those specific steps. Its pipeline combines an Adaptive Verification Manager (AVM), which scores steps by risk, with a Multi-Perspective Self-Correction Engine (MSCE), which performs intrinsic correction by reflecting on the flawed step and extrinsic correction by regenerating the step without seeing the flawed version (Zhang et al., 7 Aug 2025).

C-ToT, or comparison-based Tree-of-Thoughts, is search-oriented rather than purely reflective. It repeatedly asks the model to generate candidate intermediate thoughts, then asks the model again to compare them pairwise and keep the more promising thought from each pair. This replaces noisy pointwise scores with pairwise preferences and yields a self-calling search loop of generation, comparison, elimination, and expansion (Zhang et al., 2024).

The multimodal self-calling agent generalizes the architecture further. Its main agent emits a language-only reasoning trajectory and structured tool calls consisting of task type, prompt, and bounding box. Each tool call launches a subagent—actually the same vision-LLM in a fresh context—over a cropped image, and the subagent returns only a short textual result to the main trajectory (Yang et al., 9 Dec 2025).

3. Verification, routing, and correction

A central problem in sCoT is deciding when another self-call is warranted and where it should be applied. Recent work treats this as a routing problem rather than a uniform "always reflect" policy.

ASCoT challenges the common assumption that early errors are necessarily the most damaging. Its error-injection experiments define "Late-Stage Fragility": for correct CoTs, an injected late error is more likely to corrupt the final answer than an identical early error. On Qwen2.5-7B-Instruct, a symbolic error injected at the last step of a 4-step CoT reduces accuracy from 95.75 to 14.95, a DropRatio of about 80.80%, whereas the corresponding numeric error yields a DropRatio of about 61.70% (Zhang et al., 7 Aug 2025). To exploit this asymmetry, ASCoT defines a positional impact function

$I(k)=w_a e^{\alpha(k-1)}$

and a risk score

$R(t_k)=I(k)\,(1-Q(t_k)),$

where $Q(t_k)$ is a step-quality score. Only steps with $R(t_k)>\tau$ are sent to correction. This converts self-calling from a blanket second pass into a position-aware budget allocation scheme.

C-ToT addresses a different source of unreliability: noisy self-evaluation of candidate thoughts. Instead of asking the model for scalar scores, it asks which of two thoughts is more promising and iteratively runs elimination rounds. On AQuA, score-based ToT reports 57.1% accuracy, whereas C-ToT reaches 61.4% in standard mode and 63.0% in its dueling-bandit variant; on Sudoku, the pairwise-comparison variants likewise outperform score-based search (Zhang et al., 2024). The practical implication is that sCoT controllers need not rely on confidence scalars alone; preference queries can be a more stable self-judgment primitive.

Mechanistic evidence further suggests that routing can be grounded in internal uncertainty and structure signals. "How Chain-of-Thought Works?" argues that CoT acts as a decoding-space pruner: higher template adherence correlates strongly with improved accuracy, answer-token entropy decreases under CoT on closed-domain tasks, and later-layer neuron engagement shifts in a task-dependent manner—downward for open-domain tasks and upward for closed-domain tasks (Yang et al., 28 Jul 2025). For sCoT, this implies that template adherence, entropy over answer options, and task-type-sensitive activation signatures can serve as trigger or stopping signals for recursive calls.

4. Theoretical interpretations

The learning-theoretic account in "On the Cost and Benefit of Chain of Thought" models CoT as the interaction between an answer map $f:X\to X$ and an autoregressive chain rule $D_K$ that generates intermediate questions. The resulting reasoning risk decomposes into an oracle-trajectory risk (OTR), which captures the benefit of CoT, and a trajectory-mismatch risk (TMR), which captures the cost of deviating from the oracle trajectory (Zhang et al., 20 May 2026). OTR is the standard target-domain risk on the pushforward distribution induced by oracle reasoning; TMR is the penalty incurred when the model’s own intermediate answers alter subsequent questions. The paper shows that without stability in the loss, the answer map, or the chain rule, TMR can be arbitrarily large even when OTR is zero. Under stability, TMR is governed by an amplification factor $\alpha_K(\phi,\delta)$ with bounded, linear, and exponential error-growth regimes. For sCoT, the implication is direct: recursive self-calls help when decomposition moves the problem into a domain the model handles well and harms when intermediate deviations are strongly amplified.

A complementary complexity-theoretic perspective comes from "Chain-of-Thought and Compressed Looped Transformers: A Memory-Budget Separation" (Zhang, 29 May 2026). That work distinguishes three memory regimes: a compressed latent loop with persistent state $_1$ 0, a full sequence-state loop with $_1$ 1, and a CoT scratchpad with

$_1$ 2

Its main conclusion is that extra loop iterations do not create a growing scratchpad when persistent recurrent state is fixed: a compressed loop with small $_1$ 3 remains a small-space reasoner even if run for many steps, whereas polynomial-length CoT can solve problems unavailable to such compressed loops under the standard assumption $_1$ 4. This sharply clarifies a design choice in sCoT: repeated self-calls only increase asymptotic capability when they preserve or expand persistent mutable memory, typically by retaining intermediate tokens rather than repeatedly compressing them into a fixed-size summary.

A third theoretical strand asks how decomposition itself should be structured. "How does Chain of Thought decompose complex tasks?" models prediction as classification over $_1$ 5 possible answers and derives a power-law error scaling in the number of classes. When the task is decomposed into a balanced tree of smaller classification problems, the paper identifies an optimal degree

$_1$ 6

and an optimal depth

$_1$ 7

with a critical threshold below which more thinking is detrimental and above which depth helps only up to an optimum (Nadgir et al., 10 Apr 2026). This formalizes a common empirical observation in sCoT: additional recursive calls can reduce error when they lower local decision complexity, but "thinking longer" cannot improve performance indefinitely.

5. Multimodal, speculative, and strategic extensions

The most explicit multimodal realization of sCoT is the self-calling visual agent of "Thinking with Images via Self-Calling Agent" (Yang et al., 9 Dec 2025). It reformulates interleaved multimodal CoT as a language-only CoT whose state at time $_1$ 8 is

$_1$ 9

where $_2$ 0 are tokens generated by the main agent and $_2$ 1 are textual responses from subagents. Training uses Group-Relative Policy Optimization with reward

$_2$ 2

On HR-Bench 4K, this sCoT formulation improves overall reasoning performance by up to 1.9% with about 75% fewer GPU hours than strong interleaved multimodal baselines (Yang et al., 9 Dec 2025). The main architectural lesson is that self-calling can isolate perception from reasoning without abandoning multimodal capability.

The acronym "SCoT" is also used in unrelated but adjacent lines of work. "Efficient Reasoning for LLMs through Speculative Chain-of-Thought" uses a small draft model to generate full CoT candidates and a target model to select a draft or reject all drafts and rethink from scratch (Wang et al., 27 Apr 2025). Although not self-calling in the strict same-model sense, it instantiates a thought-level propose–verify–correct loop that is readily transferable to sCoT controllers. With $_2$ 3 drafts, it reports latency reductions of 48%–66% for DeepSeek-R1-Distill-Qwen-32B and 21%–49% for DeepSeek-R1-Distill-Llama-70B while maintaining near-target-model performance (Wang et al., 27 Apr 2025).

"Strategic Chain-of-Thought" is another separate use of the acronym. It inserts an explicit strategy-elicitation stage before step-by-step reasoning, forcing the model first to identify a suitable method and then to execute reasoning under that method (Wang et al., 2024). This is not self-calling by itself, but it supplies a modular strategy/execution split that can be turned into an sCoT pipeline by making strategy selection a callable subroutine. Its reported gains are substantial: on GSM8K with Llama3-8B, zero-shot performance rises from 52.11% to 73.16%, and on Tracking_Objects from 44.27% to 68.40% (Wang et al., 2024). A plausible implication is that many effective sCoT systems will benefit from separating planning calls from execution calls rather than treating recursive reasoning as homogeneous repetition.

6. Limitations, misconceptions, and open problems

A persistent misconception is that more recursive reasoning is necessarily better. The current literature rejects that view from multiple directions. Multiplex CoT notes diminishing returns beyond the first two rounds and acknowledges that a second pass may add no value on trivial questions, may overthink simple cases, and may even introduce new mistakes (Ji et al., 20 Jan 2025). The decomposition theory identifies an optimal depth beyond which further thinking cannot reduce minimal error (Nadgir et al., 10 Apr 2026). The learning-theoretic analysis similarly shows that deeper reasoning can amplify mismatch unless the induced dynamics are stable (Zhang et al., 20 May 2026).

A second misconception is that early errors dominate. ASCoT’s late-stage fragility results show the opposite for the tested setting: later symbolic errors can be more destructive than identical early errors, which argues against uniform verification schedules and in favor of adaptive, position-aware self-calling (Zhang et al., 7 Aug 2025).

Important practical limitations remain. Many controllers depend on proxies that are straightforward during training but problematic at deployment. In ASCoT, the process-utility term

$_2$ 4

uses the ground-truth answer $_2$ 5, so the full quality score is naturally available in training or controlled evaluation rather than unconstrained inference (Zhang et al., 7 Aug 2025). Mechanistic diagnostics proposed for trigger policies—template adherence, entropy over answer options, or layer-wise activation signatures—are informative but not yet causal guarantees of correctness (Yang et al., 28 Jul 2025).

Open problems are therefore mostly controller problems. Multiplex CoT explicitly leaves open how to decide automatically when reflection is needed, how to quantify logical consistency $_2$ 6 and coherence $_2$ 7 from text, and how many rounds $_2$ 8 are optimal per task (Ji et al., 20 Jan 2025). Speculative CoT identifies the lack of step-level correction and the use of a fixed number of drafts as limitations, pointing toward finer-grained verification and adaptive invocation (Wang et al., 27 Apr 2025). The memory-budget perspective adds a sharper warning: if an sCoT system repeatedly compresses prior reasoning into a fixed-size summary, it may inherit the limitations of compressed loops, gaining time without gaining working memory (Zhang, 29 May 2026). Together, these results define the central research agenda for sCoT: stable trigger policies, adaptive depth control, memory-aware orchestration, and correction mechanisms that improve reasoning without converting recursive introspection into recursive error amplification.