---
title: Fast-Slow Thinking in AI
url: https://www.emergentmind.com/topics/fast-slow-thinking-fst
type: topic
---

# Fast-Slow Thinking in AI

Fast-Slow-Thinking (FST) denotes a family of AI approaches inspired by Kahneman’s System 1/System 2 distinction. In the current literature, the label does not name a single architecture: it has been used for dual-mode verification inside a single LLM, fast/slow weights training with optimized context and RL-updated parameters, explicit reasoning-budget control in code models, metacognitive arbitration between fast and slow planners, and intrinsic switching between non-thinking and deliberate-thinking modes in large reasoning models [2502.11157][2605.12484][2506.09396][2303.04283][2506.02397]. Taken together, these works suggest that FST is best understood as a design principle for allocating computation, supervision, or adaptation across different time scales and reasoning depths rather than as a single algorithm.

## 1. Historical scope and conceptual range

The modern FST literature spans conditional generative modeling, online decision making, classical and epistemic planning, multi-hop visual reasoning, domain-specific conversational agents, language-conditioned robotics, visual agents, autonomous driving, hallucination mitigation, process verification, test-time reasoning control, and continual learning [1902.02812][2010.16244][2308.09658][2310.18075][2401.04181][2411.18013][2501.01306][2502.11157][2605.12484].

Some works treat fast and slow thinking as distinct computational modules. Early examples include a fast thinking initializer and slow thinking solver for conditional learning, where the initializer generates outputs directly and the solver refines them by iterative Langevin dynamics [1902.02812]. Other works cast FST as metacognitive arbitration over multiple solvers: “Interleaving Fast and Slow Decision Making” introduces a System 0 that decides whether to invoke a tabular RL policy or MCTS in Pac-Man, while “Fast and Slow Planning” and the navigation-oriented SOFAI line use a metacognitive module to choose between fast experiential policies and slow symbolic or MDFT-based solvers [2010.16244][2303.04283][2201.07050].

Other works embed FST into reasoning and multimodal inference. “Tree-of-Mixed-Thought” combines one-stop plan generation with Tree-of-Thought search for multi-hop visual reasoning; DUMA separates a user-facing fast conversational model from an internal slow ReAct-style model; RFST routes language-conditioned robotic manipulation tasks to either a direct policy or a VLM-mediated planning stack; FASIONAD combines a BEV fast planner with a VLM slow pathway for challenging driving scenes; and the visual-agent FaST framework uses a switch adapter to decide whether extra proposal and segmentation reasoning is needed [2308.09658][2310.18075][2401.04181][2411.18013][2408.08862].

A later strand centers on large reasoning models and verifiers. Dyve operationalizes fast thinking as immediate token-level confirmation and slow thinking as extended `<think> ... </think>` analysis for step verification; HaluSearch frames auto-regressive decoding as System 1 and MCTS-guided sentence-level search as System 2; OThink-R1 distinguishes redundant from essential reasoning and trains a single model to switch intrinsically; Thinker explicitly decomposes QA into Fast Thinking, Verification, Slow Thinking, and Summarization; FAST for LVLMs adapts reasoning depth to question difficulty and image complexity; AlphaOne and “Controlling Thinking Speed in Reasoning Models” modulate slow-to-fast transitions at test time without retraining [2502.11157][2501.01306][2506.02397][2505.21097][2504.18458][2505.24863][2507.03704].

## 2. Recurrent architectural patterns

Across the literature, FST recurs in a small number of architectural motifs. Some are explicit dual-module systems; others are single-model mode changes; still others are dual-timescale learning schemes.

| Pattern | Representative systems | Fast / slow substrate |
|---|---|---|
| Single-model mode switching | Dyve, OThink-R1, FAST, test-time speed control | Short `+/-` or empty `<think>` vs long `<think>` reasoning |
| Multi-module systems with controller | SOFAI, System 0 Pac-Man, DUMA, RFST, FASIONAD, visual-agent FaST | Fast policy/planner plus slow planner, VLM, or tool chain |
| Dual-timescale learning | Fast-Slow Training, cooperative conditional learning | Slow weights or energy solver plus fast prompts or fast initializer |

In the single-model variant, fast and slow are different output regimes of one network. Dyve makes this explicit: System 1 mode emits very short outputs such as “+” or “-”, while System 2 mode emits `<think> ... </think>` followed by the final label; the control flow remains the same, but the type and length of \(r_t\) changes, with verification formalized as \(r_t = \text{Dyve}(s_{1:t}; \theta)\) [2502.11157]. OThink-R1 keeps the same `<think>` tags even in fast mode, but prunes their contents to near-empty traces and trains a single policy with a dual-reference KL loss so that inference-time switching is intrinsic rather than routed externally [2506.02397]. FAST for LVLMs likewise uses one prompt and one model, but learns short reasoning on low-complexity inputs and longer chains on difficult visual-math instances [2504.18458]. Representation-editing methods push this one-model view further by treating fast and slow as directions in hidden space rather than distinct prompts or modules [2507.03704].

In the modular variant, a controller chooses between heterogeneous subsystems. DUMA’s Fast Mind is the only model that directly talks to users, while Slow Mind is invoked only when Fast Mind emits `Invoke[True]`; Slow Mind then runs a ReAct-style `Reason → Act → Obs → Finish` loop and feeds its result back to Fast Mind [2310.18075]. RFST first classifies the instruction with a Think Bank and sentence-embedding nearest-neighbor discriminator, then either executes a direct policy or invokes a VLM that generates intermediate text \(z\) so that \(y \sim p_\theta(y \mid x, z)\) for difficult tasks [2401.04181]. FASIONAD uses a BEV fast planner for routine scenes and a VLM slow pathway for long-tail cases, with the slow outputs \((\mathcal{P}_t,\mathcal{A}_t)\) fused back into the fast planner through an information bottleneck and attention updates [2411.18013]. Visual-agent FaST similarly introduces a switch adapter that outputs missing objects and context clues, then triggers proposal and segmentation adapters only when a single-pass answer is insufficient [2408.08862].

In the dual-timescale-learning variant, fast and slow are not primarily inference modes but storage and update substrates. Fast-Slow Training defines slow weights as parameters \(\theta\), updated by RLVR, and fast weights as a textual prompt population \(\Phi\), updated by GEPA, with joint objective
\[
J(\theta,\Phi) = \mathbb{E}_{x\sim\mathcal{D},\,\phi\sim U(\Phi),\,y\sim\pi_\theta(\cdot\mid x,\phi)} \left[r(x,y)\right].
\]
The result is a two-channel system in which task-specific adaptation is absorbed by context while slow weights remain closer to the base model [2605.12484]. The 2019 cooperative-training formulation uses a fast initializer \(g(X,C;\alpha)\) and a slow conditional energy solver \(f(Y,C;\theta)\), with the solver refining the initializer’s proposal and the initializer learning from the solver’s refinement [1902.02812].

## 3. Switching mechanisms and metacognitive control

The central FST question is not only what the two modes are, but when to use them. Existing systems implement this choice through hand-designed rules, learned uncertainty signals, supervision-induced escalation, or direct hidden-state control.

Rule-based metacognition appears prominently in early planning work. System 0 in Pac-Man chooses between System 1 and System 2 at each decision point; arbitrary switching performs poorly, but state-dependent policies based on ghost proximity, game progress, or location difficulty can dominate both pure S1 and pure S2 in score-time trade-off [2010.16244]. SOFAI’s MC1/MC2 controller accepts fast decisions when there is enough experience, current performance is not underperforming, and confidence exceeds threshold, but escalates to a slower expected-value-of-computation analysis otherwise [2201.07050]. Tree-of-Mixed-Thought uses structural heuristics rather than learned gating: ToT-OS allows one-stop completion only after a specified depth, and ToT-Block chooses a fixed block size \(k\) for multi-step expansions [2308.09658]. FASIONAD’s switch is driven by reward quality and Laplace-modeled uncertainty: high mismatch or wide reward distribution activates the slow VLM pathway [2411.18013].

A second family uses learned or supervision-induced escalation. Dyve does not use a hard-coded threshold at inference; instead, fast versus slow behavior is induced during training by step-wise process supervision that marks straightforward steps with `+` and uncertain or incorrect steps with detailed reasoning plus “-” [2502.11157]. OThink-R1 similarly avoids an external router: fast/slow mode is encoded in the model’s learned conditional distribution, with training data mixing empty-`<think>` and full-`<think>` trajectories after redundancy classification by an LLM-Judge [2506.02397]. HaluSearch makes switching explicit at two levels: an instance-level switch sends easy questions to direct generation and hard ones to MCTS, while a step-level switch decides whether a selected node in the search tree should receive full multi-branch expansion or only a single continuation [2501.01306]. Visual-agent FaST’s switch adapter uses the same image-question input as the base model but outputs missing objects and context clues, thereby deciding whether System 2 perception and segmentation are necessary [2408.08862].

A third family treats switching itself as a manipulable latent variable. AlphaOne introduces an \(\alpha\) moment that scales the thinking phase to \(\alpha\overline{N}_{\text{think}}\), then modulates slow-thinking transition tokens before that point as a Bernoulli process with probability \(p_t=\mathcal{S}(t)\); after the \(\alpha\) moment, generated `"wait"` tokens are deterministically replaced with `"</think>"`, forcing a fast transition to answer generation [2505.24863]. “Controlling Thinking Speed in Reasoning Models” identifies a steering vector \(v^l\) in representation space and edits hidden states by
\[
h^{l} \leftarrow h^l + \alpha \cdot v^l,
\]
with \(\alpha>0\) pushing toward concise reasoning and \(\alpha<0\) toward longer reflective reasoning. It then estimates token-level difficulty by Jensen–Shannon divergence between early and final layer logits and adapts \(\alpha\) online, producing fast processing of easy steps and deeper analysis for difficult ones [2507.03704].

## 4. Supervision, optimization, and learning regimes

FST systems differ most sharply in how they are trained. Some rely on curated process supervision, some on RL with stage-local rewards, some on prompt evolution plus policy optimization, and some on cooperative distillation from a slow optimizer into a fast generator.

Dyve’s supervision pipeline is explicitly step-wise and consensus-filtered. It collects about 15K math problems, around 20 rollouts per query using OmegaPRM MCTS, and a raw pool of about 1.2M rollouts; DeepSeek V3 re-checks the identified first error steps, about half of the noisy rollouts are discarded, and the dataset is rebalanced to about 117K high-quality examples. The resulting targets encode two regimes: simple steps mapped to `<think> </think> +` or just `+`, and uncertain or incorrect steps mapped to detailed `<think>` analysis plus `Answer: -`. Dyve then fine-tunes DeepSeek-R1-Distill-Qwen-14B with standard supervised cross-entropy on these mixed targets [2502.11157].

Fast-Slow Training turns the distinction into a dual-loop optimization problem. Slow learning updates \(\theta\) by GRPO/CISPO-style RL with verifiable rewards, while fast learning updates a prompt population \(\Phi\) by GEPA, a reflective evolutionary algorithm that critiques failures and proposes textual mutations through a frozen reflection model. Because fast weights can absorb task-specific heuristics, the RL updates on \(\theta\) need not move as far from the base model to reach a target reward [2605.12484].

Thinker makes the decomposition even more explicit by defining four RL stages: Fast Thinking, Verification, Slow Thinking, and Summarization. Fast Thinking is constrained to a maximum generation length of 1000 tokens and rewarded by \(R_{\text{fast}} = 1\{y_{\text{fast}} = y^*\}\); Verification predicts `\boxed{Yes}` or `\boxed{No}` with a weighted reward tied to fast-answer correctness; Slow Thinking receives a 6000-token budget and reward \(R_{\text{slow}} = 1\{y_{\text{slow}} = y^*\}\); Summarization distills successful slow traces back into concise forms, with reward
\[
R_{\text{summary}} = 1\{y_{\text{summary}} = y_{\text{slow}}\} + c \log P(a_{\text{summary}} \mid x_{\text{fast}}).
\]
Crucially, later-stage rewards are not propagated back to earlier stages, so intuition, verification, refinement, and distillation receive distinct credit signals [2505.21097].

FAST for LVLMs uses GRPO but makes both reward shaping and KL regularization difficulty-aware. Difficulty is \(S_{\text{difficulty}}=1-\text{pass@k}\); image complexity is estimated from entropy terms and combined as \(S_{\text{complexity}}=S_{\text{difficulty}}\cdot H_{\text{img}}\). The total reward is \(r_i = r_a + \lambda_f r_f + \lambda_t r_t\), where \(r_t\) rewards shorter correct traces on low-complexity questions and longer exploratory traces on high-complexity incorrect ones. A difficulty-aware KL coefficient,
\[
\beta_d = \beta_{\min} + (\beta_{\max} - \beta_{\min}) \cdot (1 - S_{\text{difficulty}}),
\]
keeps easy examples near the base policy while allowing more exploration on hard ones [2504.18458].

OThink-R1 uses a different route: it first keeps only correct trajectories, partitions cases into overlap and LRM-only groups, classifies overlap trajectories as Redundant Reasoning or Essential Reasoning with a GPT-4o LLM-Judge, prunes redundant `<think>` contents, and trains a single model with supervised likelihood plus dual KL to both a slow-thinking LRM and a fast-thinking non-reasoning LLM:
\[
\mathcal{L}_{\text{hybrid}}
= -\mathbb{E}_{(x,y)\in\mathcal{D}_{\text{SFT}} \big[\log \pi_{\theta}(y\vert x)\big]
+ \beta_1 \text{KL}(\pi_{\theta}\Vert\pi_{\text{LRM}})
+ \beta_2 \text{KL}(\pi_{\theta}\Vert\pi_{\text{LLM}}).
\]
The 2019 cooperative formulation reaches the same broad goal through another mechanism: the slow energy solver is trained by a contrastive-gradient objective, while the fast initializer is trained by regression toward solver-refined outputs, so that fast generation gradually amortizes slow iterative refinement [2506.02397][1902.02812].

## 5. Empirical findings across domains

The main empirical claim of the FST literature is not merely that slow reasoning can help, but that selective slow reasoning can improve the accuracy–latency or accuracy–token trade-off relative to both always-fast and always-slow baselines.

In process verification, Dyve 14B reports ProcessBench F1 of 68.5 on GSM8K, 58.3 on MATH, 49.0 on OlympiadBench, and 47.2 on OmniMATH, outperforming both pure fast-thinking PRMs and strong LLM-as-Judge baselines. In MATH-500 Best-of-N with \(N=8\), Dyve verification reaches 95.5% accuracy with a DeepSeek-R1-Distill-Qwen-14B proposer and 90.4% with a Qwen2.5-Math-7B proposer [2502.11157].

In reasoning-model efficiency, OThink-R1 reports that DeepSeek-R1-style reasoning redundancy is reduced by about 23.4% on average across four QA and math tasks, with fast-thinking used on about 27.3% of test problems on average; FAST for LVLMs reports over 10% relative improvement compared to the base model while reducing token usage by 32.7–67.3% compared to previous slow-thinking approaches; and hidden-state speed control reports an average +1.3% accuracy with -8.6% token usage across leading LRMs and advanced reasoning benchmarks [2506.02397][2504.18458][2507.03704].

In continual adaptation, Fast-Slow Training is up to 3x more sample-efficient than only slow learning across reasoning tasks, reaches higher fitted asymptotes such as 47.4% vs 43.0% on CodeIO, 49.2% vs 46.4% on Math (Polaris), and 25.0% vs 17.3% on HoVer-hard, and stays closer to the base model with up to 70% less KL divergence. In plasticity probes, RL-only initialization can collapse on HoVer-hard after Math training, whereas FST-initialized models continue to learn [2605.12484].

Embodied and interactive systems show analogous trade-offs. FASIONAD reports open-loop nuScenes performance of L2 avg \(=0.28\) m and collision avg \(=0.09\%\) with ego-state input, while running at 6.9 FPS, and the visual-agent FaST framework reports 80.8% accuracy over VQA\(^\text{v2}\) and 48.7% GIoU over ReasonSeg [2411.18013][2408.08862]. In Pac-Man, a ghost-proximity System 0 policy that invokes System 2 in danger reaches win rate 0.4435 with average time 1.8958 s, outperforming pure System 2 at 0.3645 win rate and 2.7114 s [2010.16244]. In planning, SOFAI variants solve more instances than pure Fast Downward or EFP under the reported budgets, for example 593 or 671 solved classical-planning instances versus 586 for Fast Downward, and 222 solved epistemic-planning instances versus 149 for EFP [2303.04283].

These results support a broad but qualified pattern: FST tends to help most when the task distribution mixes easy and hard instances, when a reliable internal or external signal for escalation exists, and when the cost of uniform slowness is substantial. A plausible implication is that FST is best viewed as a compute-allocation strategy grounded in learned or engineered metacognition rather than as a generic synonym for “longer chain-of-thought.”

## 6. Conceptual issues, misconceptions, and open problems

A common misconception is that FST necessarily means two separate models. The literature is divided: Dyve, OThink-R1, FAST, AlphaOne, and representation-edited speed control operate within a single model, whereas DUMA, RFST, FASIONAD, SOFAI, and visual-agent FaST use explicit multi-module decompositions [2502.11157][2506.02397][2504.18458][2310.18075]. Another misconception is that fast thinking is simply lower-quality thinking. Several systems instead report that selective fast reasoning on easy steps or instances improves global accuracy–cost trade-offs, because uniform slow reasoning can introduce overthinking, latency, redundancy, or drift from the base model [2504.18458][2507.03704][2411.18013].

The main controversies concern supervision quality, controller reliability, and the ontology of “thinking.” OThink-R1 depends on GPT-4o-based redundancy classification and acknowledges that mislabeling essential reasoning as redundant can hurt performance; HaluSearch depends on the reward model quality because tree search is only as good as its evaluator; Fast-Slow Training depends on strong textual feedback and a reflection LM; DUMA’s gating is prompt- and SFT-dependent rather than explicitly calibrated [2506.02397][2501.01306][2605.12484][2310.18075]. These systems therefore differ sharply in what they operationalize as “slow thinking”: extra tokens, extra search, extra tool use, extra optimization, or extra state updates in context.

Open problems recur across papers. Compute efficiency remains unresolved: FST can be more efficient than always-slow baselines, yet many methods still add GEPA cycles, reflection calls, tree search, multiple rollouts, or VLM invocations [2605.12484][2501.01306]. Robust switch calibration remains difficult: FASIONAD notes switching overhead and lack of formal safety guarantees; FAST still relies on model-based difficulty metrics and substantial RL compute; code-generation work explicitly calls for new benchmarks that log reasoning traces, token usage, and latency, rather than only pass@k [2411.18013][2504.18458][2506.09396]. More generally, the literature asks how to scale dual-timescale learning to larger models and more domains, how to formalize the division into declarative context versus procedural weights, how to design architectures with explicit fast-weight modules instead of purely textual prompts, and how to schedule fast versus slow updates under stationary and non-stationary task regimes [2605.12484].

Across these debates, one conclusion is stable: FST has evolved from a cognitive metaphor into a family of operational design patterns for reasoning systems. What remains unsettled is not whether fast/slow distinctions can be implemented, but which substrate—prompt population, hidden-state control, metacognitive routing, energy-based refinement, process supervision, or tool-mediated planning—best realizes them for a given domain.

Source: https://www.emergentmind.com/topics/fast-slow-thinking-fst