Decoding AI’s Thought Process: A State-Based Analysis of Large Reasoning Models

TLDR: A new research paper introduces a Finite State Machine (FSM) framework to model and analyze the hierarchical reasoning processes of Large Reasoning Models (LRMs). It categorizes AI’s reasoning steps into six discrete states: initialization, deduction, augmentation, uncertainty estimation, backtracking, and final conclusion. By mapping reasoning trajectories to these states, the framework reveals distinct patterns in how models solve problems, showing that FSM length and state transitions correlate with performance, especially in mathematical tasks. This systematic approach offers a powerful tool for interpreting, comparing, and improving AI reasoning.

Large Language Models (LLMs) have shown incredible abilities in solving complex problems, especially when they break down their solutions step-by-step, a method known as Chain-of-Thought (CoT) reasoning. Models trained with CoT examples, often called Large Reasoning Models (LRMs), seem to develop hierarchical thinking strategies that resemble how humans think. However, truly understanding these emerging reasoning capabilities in LRMs has been a significant challenge.

A recent research paper, “Modeling Hierarchical Thinking in Large Reasoning Models,” by G M Shahariar, Ali Nazari, Erfan Shayegani, and Nael Abu-Ghazaleh from the University of California, Riverside, introduces a novel approach to tackle this problem. The researchers propose using a memoryless Finite State Machine (FSM) framework to approximate and interpret the hierarchical reasoning dynamics of LRMs. This framework offers a structured and understandable way to visualize how these models approach problems.

The Six States of AI Reasoning

The core of this FSM framework is a small set of six discrete reasoning states that capture the high-level phases in a model’s thought process:

• Initialization (init): This is where the model interprets or rephrases the problem, setting the stage for its approach.
• Deduction (deduce): The model performs logical, step-by-step reasoning, calculations, or draws intermediate conclusions based on known information. This is considered the ‘default’ problem-solving state.
• Augmentation Strategy (augment): Here, the model employs auxiliary strategies to strengthen its reasoning. This can involve recalling external knowledge (augment-fact), planning a solution (augment-plan), testing examples (augment-test), exploring alternative paths (augment-branch), refining previous steps (augment-refine), or using other emergent tactics (augment-emerge).
• Uncertainty Estimation (uncertain): The model explicitly expresses doubt, confusion, or a lack of confidence about its current steps, assumptions, or calculations. This state often triggers a shift to deduction, augmentation, or backtracking to resolve the uncertainty.
• Backtracking (backtrack): The model revisits previous steps, assumptions, or re-reads the question, often after realizing an error or facing uncertainty. It’s a reset to address something missed or done incorrectly.
• Final Conclusion (closure): This is the terminating state where the model decides on a final answer or summary of its solution.

By annotating each step of a model’s Chain-of-Thought with these states, the researchers can represent the entire reasoning trajectory as a sequence of transitions through this state graph. This FSM formulation provides a systematic way to analyze, interpret, and visualize how different models approach problems.

Experiments and Key Findings

To test their framework, the researchers generated CoT reasoning from three advanced open reasoning models—Qwen3-4B-Thinking, Phi-4-reasoning, and gpt-oss-20b—on two benchmark datasets: AIME 25 (mathematical problems) and GPQA Diamond (open-domain factual knowledge). They used an LLM-based auto-labeling approach to annotate the reasoning steps at both sentence and paragraph levels.

Their experiments revealed several crucial insights:

1. FSM Length and Accuracy: Longer FSM trajectories strongly correlated with higher accuracy on structured mathematical problems. High-performing models sustained long, multi-state reasoning paths, often revisiting assumptions and refining plans. However, this correlation weakened for open-domain factual knowledge tasks, where excessively long reasoning sometimes introduced redundancy rather than precision.
2. Reasoning Patterns: High-performing models frequently combined consistent deduction with periods of uncertainty assessment and occasional backtracking. Weaker models, in contrast, tended to explore less and conclude prematurely.
3. Task-Specific Strategies: Mathematical reasoning was found to be goal-oriented, with strong models actively using augmentation and uncertainty estimation to explore and refine steps. Scientific knowledge reasoning, on the other hand, was evidence-driven, where strong models built answers step-by-step, combining augmentation and deduction with active uncertainty estimation to adjust beliefs.

The study highlights that effective reasoning isn’t just about the length of the reasoning chain but how models adaptively regulate their cognitive states to support iterative refinement and stable convergence. Regardless of the model’s capacity, reasoning trajectories consistently traverse the same fixed state space, with variations arising from how intensively and adaptively models move through this shared FSM structure.

Also Read:

• Mapping the Dynamics of Human Thought: A Quantitative Framework for Reasoning
• Bridging the Gap: How Symbolic AI Enhances Transparency and Reasoning in Large Language Models

Future Implications

This FSM framework offers more than just interpretability; it opens doors for several practical applications. It could enable greater controllability over reasoning by biasing models towards productive state patterns, facilitate error localization by identifying failure-prone state sequences, and provide valuable training feedback for curriculum design. Furthermore, it could aid in transfer learning, enhance adversarial robustness by detecting abnormal transition patterns, support reasoning editing and verification, and even help in overthinking mitigation by identifying and pruning redundant reasoning steps.

In essence, this research provides a powerful, model-agnostic foundation for understanding, comparing, and ultimately improving the reasoning capabilities of large language models. For more details, you can read the full paper here.