How Can We Make System 1 LLMs Exhibit System 2 Capabilities?

An Unresolved Core Question

On Hacker News, a post with just 5 points and zero comments raised a question worth pondering: How to make System 1 LLMs show System 2 competencies?

Though brief, this question touches on a fundamental tension in current large language model research. The concepts of System 1 and System 2 originate from psychologist Daniel Kahneman's classic book Thinking, Fast and Slow. The former refers to fast, intuitive, automatic thought processes; the latter to slow, deliberate reasoning that requires intentional effort.

Projecting this pair of concepts onto LLMs: today's mainstream large language models are essentially "fast thinking" machines. They generate text token by token based on the probability distribution of the next token, completing output in a single forward pass, with no genuine "stop and think" step. Meanwhile, the planning, verification, backtracking, and self-correction capabilities that System 2 represents are precisely where current models are weakest.

The value of this question lies in that it doesn't ask "can we make the model smarter," but rather "can we inject slow-thinking mechanisms into a fast-thinking architecture." This is an engineering problem, and also a cognitive architecture problem.

Kahneman's dual-system theory comes from his 2011 book Thinking, Fast and Slow. System 1 handles fast, automatic, unconscious cognitive processing—such as recognizing faces, understanding sentences in one's native language, and making intuitive judgments. System 2 handles slow, controlled processing that requires working memory—such as complex arithmetic, logical deduction, and self-monitoring. The key difference between the two is not difficulty, but how cognitive resources are consumed: System 2 requires attentional resources, has limited capacity, and can be actively interrupted and revised. Kahneman also pointed out that many systematic biases in human decision-making (such as anchoring effects and availability heuristics) stem from System 1's automatic outputs not being effectively reviewed by System 2. After this framework was introduced into AI research, it became a common lens for analyzing LLM reasoning deficiencies—it's not that the model "isn't smart enough," but that it only has one default fast-processing channel.

Why Do System 1 LLMs Naturally Lack System 2 Capabilities?

To fundamentally understand this question, we need to return to the inference mechanism of the Transformer.

The essence of autoregressive generation is "given the preceding text, predict the next most likely word." This process is greedy, local, and non-backtrackable. The model cannot say mid-generation, "Wait, I might have made an error in step three earlier—let me go back and redo it." It has no scratchpad for working memory, no search tree, and no explicit verification loop.

The deeper contradiction lies in the training objective. The pretraining phase optimizes for next-token prediction accuracy, which is a classic System 1 task—pattern matching and statistical association. What the model learns is "what kind of text typically follows what kind of text," not "what reasoning steps are logically valid."

Even after alignment training such as RLHF, what the model learns is more like "what kind of response people will like," rather than "what reasoning chain is correct." This leads to a phenomenon: the model can fluently generate seemingly reasonable reasoning processes, but these processes have not necessarily undergone genuine logical verification.

Autoregressive generation is the core working method of current mainstream LLMs: the model takes the already-generated token sequence as input, outputs a probability distribution over the next token, samples one, appends it to the end of the sequence, and repeats. This means generation is unidirectional and irreversible—each step's output immediately becomes a hard constraint for subsequent steps. From the perspective of the computational graph, each forward pass of a Transformer is an independent, stateless function call, with no recurrent connections across tokens between layers (hidden state passing as in RNNs does not exist in the standard Transformer). Therefore, the model has no "internal scratchpad" to temporarily store intermediate reasoning results and revise them repeatedly. So-called "working memory" in the standard architecture is entirely embodied in the already-generated output text itself. This explains why CoT works: it essentially uses the externally visible token sequence as an implicit memory buffer.

Mainstream Paths for Making System 1 Models Exhibit System 2 Capabilities

Chain-of-Thought Prompting: Trading Output for Reasoning

CoT (Chain-of-Thought) prompting is the most direct approach. By guiding the model to "take it step by step," the intermediate reasoning process is explicitly written into the output sequence, effectively trading generation space for reasoning depth.

The cleverness of this method is that it doesn't change the model architecture, only the input distribution at inference time. Each piece of generated reasoning text becomes the contextual condition for the next generation step, forming an implicit "working memory." But its limitations are also obvious: once the reasoning chain is generated, it cannot be revised, and errors propagate and amplify along the chain.

Inference-Time Compute: Letting the Model "Think Longer"

An important trend in recent years is shifting computation from training time to inference time. Representative approaches include:

• Self-consistency sampling: Generate multiple reasoning paths for the same question and select the most consistent answer through majority voting.
• Tree search and backtracking: Organize the reasoning process into a search tree, allowing evaluation of intermediate steps, pruning, and backtracking.
• Self-verification and correction: Have the model generate an answer, then use an independent verification step to check it, regenerating if errors are found.

The common logic of these methods is: System 2 capabilities don't necessarily have to be internalized in the weights—they can also be "bolted on" at inference time through additional computational processes.

Inference-time compute is relative to training-time compute. Traditional scaling laws focus on increasing model parameters and training data to improve performance; the core idea of inference-time compute is: under fixed model weights, improve output quality by increasing the compute consumed in a single inference. Self-consistency was proposed by Wang et al. in 2022—sampling multiple CoT paths for the same question and taking the majority answer, essentially approximating "ensemble learning" through sampling diversity. Tree search methods (such as Tree of Thoughts) organize reasoning steps into evaluable, prunable nodes, combining LLMs with classical search algorithms. Self-verification uses the model itself to score or critique candidate answers, forming an asynchronous generate-verify loop. OpenAI's o1 series models are precisely the engineering embodiment of this direction—training models through reinforcement learning to unfold longer internal chains of thought at inference time.

Architectural-Level Attempts

More radical directions involve introducing System 2 mechanisms at the architectural level. For example, equipping models with explicit working memory modules, allowing intermediate states to be repeatedly read and written, and introducing recurrent computation so information can flow through multiple rounds. Such work is still in its early stages, but it represents a path from "faster System 1" to "System 2-like."

Key Disagreement: Can Capabilities Actually Be "Induced"?

There is an unresolved disagreement in this field.

One view holds that System 2 capabilities are essentially already implicit in model weights, and merely need the right prompts or compute budget to be "activated." Proponents of this view would point out that the same model performs dramatically differently under different prompts, indicating that the capabilities potentially exist.

The other view is more pessimistic: if the pretraining objective never rewarded genuine logical reasoning, then what the model learned is merely the "surface form" of reasoning—imitation at the level of language patterns, not a transferable reasoning core. From this perspective, no amount of prompt engineering is anything more than superficial tinkering, and the model will expose its fundamental fragility on out-of-distribution problems.

Both views have supporting evidence. The former explains why large models can achieve significant improvements through CoT on tasks like math and code; the latter explains why models make elementary errors on slightly transformed problems, and why they "confidently spout nonsense."

Out-of-distribution generalization is a key concept for understanding this disagreement. If System 2 capabilities were truly internalized in the weights, the model should maintain stable performance on reasoning tasks outside the training distribution. But extensive experiments show that model performance drops significantly when facing surface-form changes (such as renaming variables, adjusting question word order, adding irrelevant distractor information), suggesting that the model may rely on statistical shortcuts in the training data rather than transferable reasoning rules. The side supporting "latent capability" cites the grokking phenomenon—certain capabilities suddenly emerge late in training, hinting that the model does form structured representations internally and merely needs the right trigger conditions. The essence of this debate is: does the LLM learn the computational process of reasoning, or the distribution of reasoning results? There is no consensus yet, but this question directly determines whether we should invest in prompt engineering or architectural innovation.

What This Means for Practitioners

For those building AI applications, this question has direct engineering implications.

If you need a model to complete tasks requiring multi-step reasoning, simply switching to a larger model isn't necessarily the optimal solution. A more effective strategy is often to design an appropriate reasoning pipeline: provide draft space for the model, introduce external tools for verification, set checkpoints at critical steps, and allow multiple attempts with selection of the best.

In other words, rather than waiting for a model that is "naturally System 2," it's better to build System 2 scaffolding for System 1 models at the application layer. This may be the highest return-on-investment direction right now.

The original question was just one sentence, but what it points to is the barrier that LLMs must cross on the path from "language imitators" to "reliable reasoners."

One-line Summary

Exploring how to make fundamentally System 1 LLMs exhibit System 2 reasoning capabilities like planning and verification, and the engineering paths to get there.

Paragraph Summary

The article revolves around the core question of "how to make System 1 LLMs exhibit System 2 capabilities." First, drawing on Kahneman's dual-system theory, it points out that mainstream LLMs based on autoregressive generation are essentially fast-thinking machines, lacking planning, verification, and backtracking mechanisms—rooted in the fact that the pretraining objective optimizes token prediction rather than logical validity. It then outlines three mainstream paths: chain-of-thought prompting trading output space for reasoning depth, inference-time compute (self-consistency sampling, tree search, self-verification) bolting System 2 onto the inference stage, and architectural-level introduction of working memory and recurrent computation. The article further presents the key disagreement: whether System 2 capabilities are latent abilities induced by prompting, or whether they require fundamentally changing the training objective. Finally, it offers practical advice—building reasoning scaffolding for System 1 models at the application layer offers better return on investment than simply pursuing larger models.