💬 NLP

ReasoningFlow: Discourse Structures for Understanding LLM Reasoning Traces

This paper introduces ReasoningFlow, a framework that converts complex, non-linear large reasoning model (LRM) traces into fine-grained directed acyclic graphs to analyze their discourse structures, revealing that LRMs exhibit structurally similar reasoning patterns across different models and that most erroneous steps do not influence final answers.

Original authors: Jinu Lee, Shivam Agarwal, Amruta Parulekar, Siddarth Madala, Dilek Hakkani-Tur, Julia Hockenmaier

Published 2026-06-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jinu Lee, Shivam Agarwal, Amruta Parulekar, Siddarth Madala, Dilek Hakkani-Tur, Julia Hockenmaier

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are watching a genius mathematician solve a complex puzzle. They don't just write down the answer in a straight line. Instead, they talk to themselves: "Wait, that number looks wrong," "Let me try a different path," "Oh, I see, I made a mistake here, let me go back," and "Okay, now I'm sure."

For a long time, computers trying to understand these "thought processes" (called reasoning traces) only saw a straight line of text. They couldn't see the backtracking, the self-corrections, or the dead ends. They just saw a messy paragraph.

This paper introduces ReasoningFlow, a new way to map out these messy thoughts into a clear, visual flowchart (specifically, a Directed Acyclic Graph, or DAG). Think of it like turning a chaotic stream of consciousness into a subway map where every station is a thought, and every track shows how one thought leads to another.

Here is what the researchers found, explained simply:

1. The Map: Turning Thoughts into a Flowchart

The researchers built a system to break down these long, winding reasoning traces into small chunks (nodes) and draw lines (edges) between them to show how they connect.

The Nodes (Stations): They identified 8 types of "stops" on the map. Some are for Planning (deciding what to do next), some for Reasoning (doing the math or logic), some for Reflection (checking if they are right), and some for Assumptions (trying a "what if" scenario).
The Edges (Tracks): They drew 14 different types of tracks. Some tracks show a logical step forward ("infer"), some show a plan being executed ("execute"), and some show a "backtrack" where the thinker realizes, "Wait, that path is wrong," and jumps back to try something else.

2. The Discovery: Everyone's Map Looks the Same

The team tested this on five different AI models (some very new "reasoning" models, some older ones) across math, science, and argument tasks.

The Finding: Even though these AI models were built by different companies and trained on different data, their "thought maps" looked surprisingly similar. It's like how a human from New York and a human from Tokyo might both use a similar mental map to solve a maze, even if they speak different languages. The structure of how they think is becoming standardized.

3. The "Self-Correction" Superpower

One of the most interesting things they found is how these AI models handle mistakes.

Local Verification: Instead of waiting until the very end to check if the whole answer is right, these models constantly check their work as they go. They catch small errors immediately and fix them.
The "Oops" Moment: The paper found that when an AI says, "Wait, that seems wrong," and changes its mind, that change is usually the key to getting the right answer. The model is actively "steering" itself away from errors in real-time.

4. The "Ghost" Errors

This is perhaps the most surprising finding.

The Myth: People used to think that if an AI made a mistake in step 3, the final answer would definitely be wrong.
The Reality: The ReasoningFlow maps showed that most errors are "ghosts." The AI might make a mistake, realize it, backtrack, and completely ignore that wrong path. The final correct answer is built on a different set of steps.
The Analogy: Imagine you are driving to a party. You take a wrong turn, realize it, turn around, and take the right road. You arrived at the party on time. If someone just looked at your GPS history, they would see the wrong turn and say, "You failed!" But the ReasoningFlow map shows that the wrong turn was a dead end that didn't affect your final arrival.

5. The "Black Box" vs. The "Script"

Finally, the researchers looked at how the AI's internal "brain" (mechanistic dependencies) matches the words it writes (discourse structure).

The Finding: They found a disconnect. Just because the AI's internal math says "Step A caused Step B" doesn't always mean the text reflects that relationship clearly. The "story" the AI tells (the text) doesn't always perfectly match the "wiring" inside the computer. It's like a magician's script (the text) not perfectly explaining the secret mechanics (the wiring) behind the trick.

Summary

ReasoningFlow is a new tool that lets us see the "subway map" of an AI's thinking. It shows us that:

AI models are developing a similar "thinking style" across different brands.
They are very good at catching their own mistakes while they are thinking, not just at the end.
Most mistakes they make are temporary dead ends that don't ruin the final answer.
What the AI says (the text) doesn't always perfectly match what is happening inside its brain.

This helps researchers understand how these models solve problems, rather than just looking at whether they got the right answer or not.

Technical Summary: ReasoningFlow: Discourse Structures for Understanding LLM Reasoning Traces

Problem Statement

Large Reasoning Models (LRMs) generate extended reasoning traces characterized by non-linear behaviors, such as backtracking, self-correction, and iterative verification. While these behaviors are crucial for complex problem-solving, they complicate the evaluation and monitoring of the reasoning process. Existing evaluation methods often rely on stepwise correctness, which may flag erroneous steps even when the final answer is correct due to subsequent self-verification. Furthermore, current frameworks for analyzing reasoning structures lack the expressiveness to capture fine-grained, sub-sentence level discourse relations or fail to validate their annotation schemas with inter-annotator agreement. Traditional discourse parsing methods (e.g., Rhetorical Structure Theory) are designed for well-organized texts and do not accommodate the goal-oriented, often left-to-right causal dependencies found in autoregressive LLM traces.

Methodology

The authors introduce ReasoningFlow, a framework designed to annotate the fine-grained discourse structures of LRM reasoning traces by converting them into Directed Acyclic Graphs (DAGs).

Annotation Schema

ReasoningFlow defines a schema comprising 8 node types and 14 edge types:

Node Types: The schema includes three core functional types—Reasoning (deduction, calculation), Planning (introducing upcoming content), and Reflection (evaluating correctness or expressing certainty). It also defines five specialized subtypes of Reasoning nodes: Fact, Restatement, Assumption, Example, and Conclusion. Nodes are contiguous, non-overlapping snippets, typically sentences, though complex sentences with distinct functional roles are split.
Edge Types: Edges represent semantic relations flowing from earlier to later steps. They are categorized into four groups: Reason (e.g., infer, execute, restate), Plan (e.g., proceed, verify), Reflect (e.g., positive, uncertain, negative), and Validate (e.g., support, attack).

Dataset Construction

Manual Annotation: To validate the schema, the authors manually annotated 31 reasoning traces (2.1k steps) across math, physics, and chemistry domains. Two annotators per trace achieved high inter-annotator agreement (Krippendorff's $\alpha > 0.8$ ) for both node classification and edge detection/classification.
Automatic Annotation: Using the validated schema, the authors scaled to automatic annotation of 1,260 traces (247.7k steps) generated by five models (Qwen2.5-32B-Inst, QwQ-32B, DeepSeek-V3, DeepSeek-R1, GPT-oss-120B) across three tasks: AIME 2024 (Math), GPQA-Diamond (Science), and ArgKP (Argumentation). The pipeline utilized LLMs (Gemini-3-Flash and Gemini-3-Pro) for segmentation, classification, and edge detection, with manual review of a subset to ensure quality.

Analysis Framework

The authors utilized the ReasoningFlow graphs to analyze:

Structural similarities across models and domains using Principal Component Analysis (PCA) on triplet distributions (node-edge-node).
Fine-grained reasoning behaviors like local verification, self-reflection sentiment, and assumption-based reasoning (proof-by-contradiction, DFS).
The causal relationship between erroneous steps and final answers.
The alignment between mechanistic causal dependencies (measured via attention masking) and language-level discourse structures.

Key Contributions and Results

1. Structural Similarity Across Models

Despite being trained on different base models and potentially non-overlapping post-training data, different LRMs (QwQ, DeepSeek-R1, GPT-oss) exhibit structurally similar reasoning traces. The Jensen-Shannon divergence between the triplet distributions of reasoning models is significantly lower than that of their non-reasoning base model counterparts, suggesting that the reasoning capability induces a shared structural pattern.

2. Fine-Grained Reasoning Behaviors

ReasoningFlow reveals diverse behaviors not captured by coarser frameworks:

Local Verification: LRMs frequently engage in local verification (correcting intermediate steps mid-trace) rather than just global verification of the final answer. Corrections are significantly more likely to be used as premises for the final answer than the original erroneous statements.
Self-Reflection Sentiment: There is a strong correlation between the sentiment of reflection nodes (positive, uncertain, negative) and the actual quality (correctness) of the reflected step. Positive reflections correlate with higher correctness (78.1%), while negative reflections correlate with lower correctness (45.6%).
Assumption Handling: The framework identifies patterns for proof-by-contradiction and depth-first search (DFS), distinguishing deliberate hypothetical reasoning from normal errors.

3. Error Propagation and Faithfulness

A critical finding is that most erroneous steps in LRMs are not causally responsible for incorrect final answers.

Approximately 79.6% of erroneous nodes do not connect to the final answer (unused).
About 6.0% of errors are connected to the final answer but lead to a correct conclusion (neglected errors), indicating the model successfully recovered or ignored the error.
Only 14.4% of erroneous nodes causally propagate to incorrect final answers.
This suggests that stepwise evaluation methods that filter traces based on intermediate errors may be overly conservative, as many errors are "unused" or "neglected" within the reasoning process.

4. Mechanistic vs. Discourse Misalignment

The paper finds that mechanistically measured causal dependencies (using "Thought Anchors" via attention masking) do not faithfully reflect language-level discourse relations. The predictive power of attention-based causal scores is not significantly better than simply selecting the $K$ most recent nodes, indicating a gap between the model's internal causal mechanisms and the surface-level discourse structure.

Significance

The paper positions ReasoningFlow as a necessary tool for understanding the "language part" of the causal reasoning procedure in LRMs. By providing a fine-grained, validated annotation schema, it enables:

Improved Monitorability: Identifying specific behaviors like local verification and self-reflection allows for better monitoring of internal model beliefs.
Refined Evaluation: Demonstrating that most errors do not propagate to the final answer challenges the efficacy of purely stepwise error filtering in Best-of-N sampling or Process Reward Models.
Bridging Mechanistic and Semantic Gaps: Highlighting the discrepancy between mechanistic dependencies and discourse structures points to a crucial area for future research in making LRMs more faithful.

The authors release the dataset (1.3k traces) and code to facilitate further research into the reasoning capabilities of LRMs, offering a human-interpretable lens for studying how reasoning behaviors emerge and function.