🤖 AI

Deep Interaction: An Efficient Human-AI Interaction Method for Large Reasoning Models

This paper introduces "Deep Interaction," an efficient human-AI interaction method that allows users to directly edit erroneous reasoning steps in Large Language Models and distill the corrected Chain-of-Thought into a prompt, resulting in a 25% higher correction success rate and 40% token reduction compared to baseline approaches.

Original authors: Hefeng Zhou, Jinxuan Zhang, Jiong Lou, Yuxin Liu, Chaochao Lu, Jingjing Qu, Jie Li

Published 2026-07-16

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Hefeng Zhou, Jinxuan Zhang, Jiong Lou, Yuxin Liu, Chaochao Lu, Jingjing Qu, Jie Li

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 trying to teach a brilliant, but slightly stubborn, robot how to solve a tricky puzzle. This robot is a Large Language Model (LLM), a type of artificial intelligence that has read almost everything on the internet and can write stories, solve math problems, and even act like a human. To help these robots think better, scientists invented a technique called "Chain-of-Thought" (CoT). Think of CoT as asking the robot to "show its work" out loud, step-by-step, like a student writing down their math homework instead of just guessing the answer. This has made robots much smarter at complex tasks.

However, there's a catch. Sometimes, the robot makes a mistake in step three of its ten-step plan. In the old way of fixing this, you would have to chat with the robot, say, "Hey, you messed up step three," and hope it listens. But often, the robot just says, "You're right, I made a mistake," and then immediately makes the exact same mistake again in the next step, or it gets confused and forgets the rest of the plan. It's like trying to correct a friend who is walking the wrong way by shouting from behind them; they might hear you, but they keep walking in circles. This is frustrating for anyone trying to use AI for serious work, like solving science problems or checking safety logic.

This is where a new idea called Deep Interaction comes in. Instead of just chatting with the robot to fix its errors, this paper proposes a method where you can directly edit the robot's "thinking process" like you would edit a document on a computer. Imagine the robot writes a story, but you can highlight a wrong sentence, delete it, and type in the correct one right there. The system then takes your edited version, cleans it up, and asks the robot to continue the story from that corrected point. The researchers found that this "direct edit" method is much faster and more accurate than the old "chat and hope" method. In their tests on tough science and math problems, this new way of interacting improved the correction success rate by over 25% (a relative increase compared to baseline methods) and reduced token usage by approximately 40% for questions that were successfully answered compared to baseline approaches.

The Problem with "Just Chatting"

When these AI models make a mistake, the usual fix is to have a conversation. You tell the AI, "That step is wrong," and it tries again. But the paper shows that this often fails. The AI might agree it was wrong, but then it gets stuck in a loop, repeating the same error or drifting off into a new, equally wrong path. It's like a GPS that keeps saying, "Recalculating route," but then sends you back to the same traffic jam. The authors argue that this happens because the AI is trying to remember the whole conversation history, which gets messy, or because it's just memorizing patterns from its training data rather than truly understanding the logic.

The Solution: Editing the "Thoughts"

The authors propose Deep Interaction, a system that treats the AI's reasoning steps like a draft document. Here is how it works in simple terms:

The Draft: The AI generates a solution with a Chain-of-Thought (its step-by-step reasoning).
The Edit: If you spot a mistake, you don't just type a message in the chat box. Instead, you directly edit the text of the AI's reasoning. You can delete a wrong step, change a number, or fix a logic gap, just like using "Track Changes" in a word processor.
The Cleanup: The system is smart enough to know what you changed. It highlights your edits, removes the parts you deleted, and cleans up any confusing leftover text. It also masks specific numbers to stop the AI from just memorizing the old wrong numbers.
The Restart: The system takes your edited version and feeds it back to the AI as a new instruction: "Here is the corrected path so far; please continue from here."

What They Found

The researchers tested this method on some very hard problems, including math, physics, chemistry, and biology questions from high school and university levels. They compared their "Deep Interaction" method against the standard "chat-based" correction method.

Better Success: The new method improved the correction success rate by over 25% compared to just chatting. For example, on a difficult set of science questions, the standard chat method got the right answer about 72% of the time after a few tries, while Deep Interaction got it right about 86% of the time.
Faster and Cheaper: Because the AI doesn't have to re-read a long, messy conversation history, it uses about 40% fewer tokens (the units of text the AI processes) for the questions it eventually solves correctly. This makes the process much more efficient.
Works on Different Models: They tested this on several different AI models, from smaller ones to very large ones. In every case, the ability to directly edit the reasoning steps helped the model perform better than just talking to it.

Why This Matters

The paper suggests that for complex tasks where the AI needs to be precise, like solving a math equation or analyzing a safety scenario, simply talking to it isn't enough. We need a way to "steer" its thinking directly. By letting humans edit the reasoning steps, we can guide the AI away from its mistakes without getting stuck in a loop of "You're right, I made a mistake" followed by the same mistake again.

The authors note that this method relies on the human being able to spot the error. If the human doesn't know what's wrong, they can't fix it. Also, if a human gives the AI the wrong correction, the AI might follow that wrong path too. But for users who know the subject matter—like students, teachers, or experts—this "Deep Interaction" offers a powerful new way to collaborate with AI, turning a frustrating conversation into a productive editing session.

Technical Summary: Deep Interaction for Large Reasoning Models

1. Problem Statement

While Chain-of-Thought (CoT) reasoning has significantly enhanced the capabilities of Large Language Models (LLMs) in tackling complex, multi-step tasks, current human-AI interaction methods for correcting errors remain inefficient. When an LLM generates a reasoning chain containing errors, standard conversational correction typically involves users flagging the mistake in a follow-up turn. However, this approach often fails because:

Repetition of Errors: The model may acknowledge the error (e.g., "You are right, I made a mistake") but subsequently regenerate a response that repeats the same error or follows a similar incorrect trajectory.
Inefficiency: Iterative dialogue requires lengthy exchanges, increasing token usage and the risk of the model losing track of key information in long context windows.
Memorization and Sticky Thinking: Models may rely on memorized training patterns or "sticky" early tokens, causing them to revert to incorrect reasoning paths even when guided by new instructions.
KV Cache Effects: In web-based interfaces, session history and KV caches can cause models to reproduce previous responses verbatim despite changes in input semantics.

Existing self-correction methods (e.g., Self-Refine, RCoT) often struggle to locate and fix their own reasoning mistakes effectively, particularly when errors are subtle or deeply embedded in the reasoning chain.

2. Methodology: Deep Interaction

The paper proposes Deep Interaction, a paradigm that shifts from conversational feedback to direct editing of the model's reasoning output. This approach treats the CoT response as a document that users can revise, similar to a "track changes" mode in word processors.

Core Framework

The process involves three main stages:

Human Editing: The user identifies an error in the model's initial CoT response ( $C_r$ ) and directly edits the text to create a corrected version ( $C'_r$ ). This allows for precise intervention in specific reasoning steps without rewriting the entire chain.
Change Tracking and Processing: The system uses the Myers Diff algorithm to detect modifications between the original and edited text. The edited CoT is segmented into three parts:
- Pre-edit: Content before the modification.
- Edit-section: The modified content.
- Post-edit: Content following the modification.
  Specific processing strategies are applied to each segment:
- Emphasis: Edited sections are highlighted (e.g., using Markdown **bold**) to draw the model's attention.
- Pruning: Low-value phrases and semantically redundant spans are removed to reduce noise.
- Removing: Subsequent content that may be invalidated by the edit is removed to prevent inconsistency, retaining only structural headers if necessary.
- Delexicalization: Numerical values are masked to prevent the model from relying on memorized surface forms rather than semantic reasoning.
Semantic Refinement (CoT Reprompter): To prevent the model from regenerating the original erroneous suffix due to sequential memorization, the edited CoT is processed by a CoT Reprompter. This component (implemented via few-shot prompting with a large LLM or fine-tuning a lightweight LLM) distills the edited content into a structured "Feedback-CoT." This ensures the new input ( $Q_{r+1}$ ) preserves the corrected semantics while reducing redundancy and breaking the link to the original error trajectory.

The final input for the next inference round is a concatenation of the original query ( $Q_r$ ) and the processed, edited CoT ( $C'_r$ ), guiding the LLM to generate a corrected response ( $C_{r+1}$ ).

3. Key Contributions

Direct Editing Paradigm: Introduction of a "revision mode" for LLM interactions, allowing users to directly edit reasoning steps rather than relying on iterative dialogue.
Fine-Grained Correction Mechanism: A technical pipeline combining text differencing (Myers Diff), semantic pruning, and delexicalization to transform human edits into effective prompts.
Distillation via CoT Reprompter: A method to convert edited CoT spans into optimized prompts that steer the model away from memorized incorrect continuations.
Empirical Validation: Comprehensive evaluation across multiple benchmarks (ScienceQA, Gaokao-MM, LogicQA, and a custom STEM20K dataset) demonstrating superior performance over dialogue-based baselines.

4. Experimental Results

The authors evaluated Deep Interaction against dialogue-based correction methods and self-correction baselines (RCoT, Self-Refine) across various models (Qwen, GPT, Gemini, Claude) and difficulty levels.

Correction Success Rate: Deep Interaction achieved a >25% improvement in correction success rates compared to baseline dialogue approaches on STEM and logical reasoning tasks.
Token Efficiency: The method reduced token usage by approximately 40% compared to multi-turn dialogue, as it avoids the accumulation of conversational history.
Performance Across Rounds:
- On the STEM20K dataset, the pass rate within 2 rounds for Deep Interaction was 79.27%, compared to 72.93% for dialogue-based methods.
- On Gaokao-MM, Deep Interaction reached 93.42% pass rate within 4 rounds, outperforming the dialogue baseline (88.85%).
- The method showed consistent gains across different model scales (Qwen2.5-VL 7B to 72B), though the absolute gains were smaller for the 7B model, indicating model capability remains a factor.
Error Type Analysis: The method was particularly effective in correcting reasoning consistency and numerical calculation errors. However, the paper notes that Image Recognition errors remain challenging, as both dialogue and editing methods struggle with visual semantic misinterpretations.
Ablation Studies: Removing any component (editable response, text processing, or CoT Reprompter) led to significant performance degradation, confirming the necessity of the full pipeline.

5. Significance and Claims

The paper positions Deep Interaction as a significant step toward efficient human-AI co-creation, particularly for complex reasoning tasks. The authors claim that:

Efficiency: It solves the inefficiency of conversational correction by enabling direct, targeted edits, significantly reducing token costs and interaction time.
Robustness: It mitigates the "sticky thinking" and memorization issues that plague standard conversational correction, allowing models to truly adjust their reasoning paths.
Scalability: The approach is effective across different model families and scales, suggesting it is a generalizable interaction method rather than one tied to a specific model architecture.
Limitations: The authors modestly acknowledge that the method relies on users having the ability to identify errors (making it more suitable for expert or semi-expert users) and that it requires models to expose intermediate reasoning traces (CoT). They also note that if a user provides incorrect guidance, the model may faithfully propagate that error.

The work is deployed as the "Human-CoT" application mode on SafeWork-R1, demonstrating its practical applicability in real-world systems.