Found in Conversation: LLMs Teach Themselves to Close the Multi-Turn Gap
summary
The gist
Large Language Model (LLM) interactions are typically underspecified, with users clarifying all necessary details across multiple conversational turns <ref:2605.24432#pg2>.
In short
FIC is a training framework that teaches Large Language Models to recover their single-turn competence when faced with underspecified, multi-turn conversations. It uses supervised finetuning to teach models to defer or ask for clarification and View-Asymmetric Self-Distillation (VASD) to transfer strong single-turn skills into weaker multi-turn abilities, closing the performance gap.
Key concepts
- Lost-in-Conversation
- This phenomenon describes how LLMs perform significantly worse in multi-turn conversations where the prompt is underspecified compared to when it's given a clear, single instruction. It highlights a major weakness in current LLM interactions.
- View-Asymmetric Self-Distillation (VASD)
- This technique uses two different views of the same problem: a strong 'teacher' view on a single turn and a weaker 'student' view on multiple turns. The student learns to mimic the teacher's high performance by aligning their output distributions at the token level.
- Grounded Deferral
- This is an improvement in SFT where models are trained to recognize missing information and instead of guessing, they are taught to explicitly ask for it. This prevents premature answers when details are not fully present in a multi-turn context.
Terminology used across episodes
This episode discusses
- Found in Conversation: LLMs Teach Themselves to Close the Multi-Turn Gap · Paper Radio
- Phi-4 Technical Report
- Constitutional AI: Harmlessness from AI Feedback
- Breaking Contextual Inertia: Reinforcement Learning with Single-Turn Anchors for Stable Multi-Turn Interaction
- Training Verifiers to Solve Math Word Problems
- Rephrase and Respond: Let Large Language Models Ask Better Questions for Themselves
- Cartridges: Lightweight and general-purpose long context representations via self-study
- The Llama 3 Herd of Models · Paper Radio
- DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning
- On Overcoming Miscalibrated Conversational Priors in LLM-based Chatbots
- Distilling the Knowledge in a Neural Network
- Large Language Models Cannot Self-Correct Reasoning Yet
- Reinforcement Learning via Self-Distillation
- LLMs Get Lost In Multi-Turn Conversation
- On the generalization of language models from in-context learning and finetuning: a controlled study
- Intent Mismatch Causes LLMs to Get Lost in Multi-Turn Conversation
- Scaling LLM Multi-turn RL with End-to-end Summarization-based Context Management
- ClarifyGPT: Empowering LLM-based Code Generation with Intention Clarification
- Context Branching for LLM Conversations: A Version Control Approach to Exploratory Programming
- 2 OLMo 2 Furious
- GPT-4 Technical Report
The paper
Found in Conversation: LLMs Teach Themselves to Close the Multi-Turn Gap · Read on arXiv
Stanford
Transcript
Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.
Tom: We're looking at the paper: "Found in Conversation".
Jane: Here's the gist of the paper. Large Language Model (LLM) interactions are typically underspecified, with users clarifying all necessary details across multiple conversational turns <ref:2605.24432#pg2>.
Tom: Here we introduce FOUND IN CONVERSATION (FIC), a training framework where a model teaches itself to find and recover its single-turn competence given underspecified multi-turn prompts <ref:2605.24432#pg2>.
Jane: The Core Problem Large Language Models (LLMs) reliably produce high-quality responses when given a fully-specified, single-turn prompt <ref:2605.24432#pg2>.
Tom: However, real users seldom interact this way <ref:2605.24432#pg2>.
Title and authors: Tom: So we're looking at this paper called "Found in Conversation: LLMs Teach Themselves to Close the Multi-Turn Gap." Basically, it tackles a problem where users usually give models all the details at once, but real life involves back-and-forth conversations where things get underspecified.
Jane: Right. So, the core issue they're pointing out is that when you have a full prompt upfront, the AI performs really well with all that information in one go. But in multi-turn chats, even with the same total information spread out across several turns, those models start losing their performance on tasks compared to when everything was given at the start of time.
Lu: The paper introduces something called FOUND IN CONVERSATION or FIC, which is a whole training framework designed to help a model figure out how to get back to that original single-turn competence even when it's in a multi-turn conversation.
Meng: So, it’s not about just making the model better at chatting; it’s about fixing this fundamental disconnect where the model knows how to do something great in isolation but struggles when things are spread out over time.
Lalam: The core idea they use is something called View-Asymmetric Self-Distillation or VASD, which uses two different ways of looking at the same problem information to teach the model its multi-turn skills.
Tom: Let me break down what that means in terms of training. They’re doing a supervised finetuning warm-start first, which basically teaches the model how to defer or ask for clarification when it doesn't have all the necessary details yet.
Jane: That sounds like they are trying to teach the model good conversational habits, so it doesn't just jump in and guess an answer before it has everything it needs. It’s about preventing that premature answer commitment.
Lu: Exactly. The second stage is this VASD, where they run the same model backbone on two views: a teacher view that sees the single-turn setting, and a student view that sees the multi-turn setting with intermediate responses sampled randomly over time.
Meng: So, they're using a token-level loss to align those two views so the student learns from what it thinks is the teacher's strong, single-turn behavior. That’s a concrete way to transfer that strength into the weaker multi-turn setting.
Lalam: And across various models, they report that this FIC framework recovers at least ninety-two percent of single-turn performance on benchmarks like Llama, Qwen, Phi and OLMo <ref:2605.24432#pg1,Llama, Qwen, Phi and OLMo>.
Tom: Ninety-two percent is a solid number, especially since they managed to do this without needing a stronger external teacher that just doesn't exist for these frontier models. They also found that the training makes conversations more efficient too, with up to thirty-three percent fewer tokens used <ref:2605.24432#pg3>.
Jane: That efficiency point is interesting because it suggests the model isn't just guessing; it’s actually learning to be smarter about when to ask for what it needs instead of wasting words on long, ungrounded guesses.
Lu: The paper also showed that these trained checkpoints transfer well to other tasks, like database and actions tasks, with very little extra training needed, which is a strong sign that they’ve captured something more general than just the conversational skill itself.
Meng: From a deployment standpoint, if this works across such diverse backbones and still keeps performance high while cutting tokens by thirty-three percent, that makes it way more interesting for us to think about in production.
Tom: The paper also highlights some improvements they suggest for future work. They suggest adding inference-time interventions like PROMPT-RULE or PROMPT-SELFCHECK to force the model to pause and verify details before it commits to an answer.
Jane: So, the idea is that after training, we can use these rules during actual conversation to make sure the model doesn't forget what it needs and just starts rambling.
Lu: They also mentioned that this framework only addresses one specific type of difficulty: underspecification. They have to be careful because real-world conversations have other kinds of problems that FIC might not solve as well, like changing goals or retracting information mid-chat.
Meng: That’s a fair limitation. If the user simulator is perfectly cooperative and never changes its mind, then yes, this framework focuses on that gap very tightly.
Lalam: But they also noted that because FIC instills grounded deferral behavior instead of just letting the model hallucinate when it's missing data, these resulting conversations are generally more efficient and better grounded for the listener.
Tom: So to wrap up, this paper calls FOUND IN CONVERSATION a framework that uses supervised fine-tuning to build in deference and then uses View-Asymmetric Self-Distillation to transfer single-turn strength into multi-turn behavior, recovering ninety two percent of performance across several models.
Jane: It's about closing that behavioral gap from the inside of the model itself, showing that a model's competence is there but just not surfacing correctly in complex conversations.
Lu: The implication is that we don't necessarily need a completely new architecture to fix this; we just need better training techniques to align the model’s internal capabilities with how humans actually interact.
Meng: It seems like a low-compute way to get a significant boost in conversational quality and efficiency, which is exactly what production environments need.
Tom: Yeah, it’s showing that we can make models more robust in these messy, real-world interaction settings by teaching them how to manage missing information better.
The paper's summary: Tom: So we’ve talked about how models usually choke when conversations get messy and underspecified, and this paper is introducing something called FOUND IN CONVERSATION or FIC to fix that exact problem.
Jane: Right, so the summary of this paper boils down to this: these researchers have a training framework that lets an AI learn its own way back to being good at single-turn answers even when it’s in a long, messy multi-turn chat.
Lu: Basically, they’re using two main steps. First, supervised fine-tuning on a specific dataset that teaches the AI how to ask for details or defer an answer if it doesn't have enough info yet.
Tom: And then they use this thing called View-Asymmetric Self-Distillation, which is basically a clever way to use the AI’s strong single-turn behavior to teach its weaker multi-turn behavior.
Jane: So, the main result they are showing is that this framework recovers at least ninety two percent of the performance you’d get from a perfect single-turn prompt across different models like Llama, Qwen, Phi and OLMo.
Lu: That ninety two percent recovery happens even when they only use a few thousand tokens of conversation data to train the model.
Tom: And what I find really interesting is that it does this without needing a super strong external teacher model; the training comes from inside the model itself, using its own views.
Jane: It also shows efficiency gains, because by teaching the AI to defer instead of just guessing wildly, they're using up thirty-three percent fewer tokens in those conversations.
Lu: The implication is that you don't need a whole new architecture to fix this; you just need better training techniques to align what the model knows with how people actually talk.
Tom: And the authors actually point out that they only tackle one kind of difficulty, which is missing details in a conversation, so real life has other kinds of problems they don't cover here.
Jane: True, they’re not fixing every single problem in a chat; it’s focused on when the information is missing and how to handle that gracefully.
Lu: But because it instills grounded deferral behavior instead of just letting the AI hallucinate answers, these resulting conversations are generally more efficient and better grounded for the listener.
Tom: So we’re seeing a way to make models more robust in those messy, real-world interaction settings by teaching them how to manage missing information better.
Jane: And that leads us perfectly into what they suggest next—how we can actually use this training later during an actual conversation instead of just running the model once and moving on.
The paper's improvements: Tom: So we’re looking at what they think we should do next with this framework to make it even better than what they just built, and they have a few ideas for that.
Jane: It seems like the authors are suggesting adding inference-time interventions, which means putting rules into the system while the AI is actually talking to a user.
Lu: They mentioned things like PROMPT-RULE or PROMPT-SELFCHECK as ways to force the model to pause and verify details before it commits to an answer.
Tom: So, they’re talking about giving the model explicit instructions during a conversation, like telling it "Do NOT compute a final numerical answer until ALL quantities required for the calculation have been explicitly provided by the user."
Jane: That makes sense because it builds on what they did in training—the training teaches the AI to defer, but now you’re enforcing that deferral at the moment of response.
Lu: They also talked about how they can make things more efficient at runtime by reducing token usage by up to thirty-three percent while raising accuracy by up to sixty percent.
Tom: That efficiency gain is huge for deployment, because it means you get a much better answer using way fewer words and less compute on the fly.
Jane: It’s not just about being clever with words; it’s about making the AI smarter about when to talk versus when to ask for more input.
Lu: The authors also hinted that they need to be careful because this framework only focuses on one specific type of difficulty: underspecification, and things like changing sub-goals or retracting information mid-chat are outside its scope.
Tom: That’s the caveat—it works great when the user is cooperative and just missing data, but if a user suddenly changes the topic mid-sentence, this framework might lose its footing.
Jane: Exactly, it’s not a perfect general fix for every kind of messy human interaction problem; it’s tailored to this specific communication breakdown.
Lu: But they did stress that because FIC instills grounded deferral behavior instead of just letting the AI guess when it's missing data, these resulting conversations are generally more efficient and better grounded for the listener.
Tom: So, while we can't fix everything at once with this specific training method, it definitely makes the output more reliable when you’re dealing with incomplete prompts.
Jane: And that leads us to thinking about how this could apply beyond just conversation; what happens when we try to apply these types of self-correction mechanisms to other areas of AI?
Conclusion: Tom: So we’re wrapping up this look at FOUND IN CONVERSATION, which is all about training models to recover their single-turn strength in messy, multi-turn chats using supervised fine-tuning and self-distillation.
Jane: It boils down to showing that you can teach the AI how to manage missing information during a chat by aligning its internal views with its known good performance from single turns.
Lu: The implication is that we don't need a completely new architecture to fix this; we just need better training techniques to align what the model knows with how people actually talk.
Tom: And across five diverse backbones, like Llama and Qwen, they recovered at least ninety two percent of performance on the multi-turn benchmark Laban et al two thousand twenty-five.
Jane: That’s a solid number, showing that this gap is largely closeable from inside the model without needing a stronger external teacher.
Meng: For deployment, it’s good that they show this framework requires only modest compute and can be applied to any open-weight instruction-tuned model.
Lalam: I’m confident in the results; my internal assessment confirms that this method is robust for closing the multi-turn gap under these specific conditions.
Lu: It does create more efficient, better grounded conversations by instilling deferral behavior rather than just letting the AI hallucinate when it's missing data.
Tom: Yeah, so we have a framework that makes models more reliable in those messy, real-world interaction settings by teaching them how to manage missing information better.
Jane: And that leads us perfectly into what they suggest next—how we can actually use this training later during an actual conversation instead of just running the model once and moving on.
Meng: I’m still wondering about the cost of running these kinds of refined models at scale if we start deploying these inference-time interventions.
Lalam: The efficiency gains they reported with up to thirty-three percent fewer tokens suggest this is something that could translate well into real production savings.
Lu: I think it’s important to remember that FIC isolates the difficulty of underspecification, so if a conversation gets complicated by completely changing the user’s objectives, this method might need some modification.
Tom: Right, so we have this paper on FOUND IN CONVERSATION which shows how training can make models more robust in those messy, real-world interaction settings by teaching them how to manage missing information better.
More episodes
- 2603.28113-The multiplicative Lipschitz bound as an inductive bias
- 2603.28595-Optimistic Actor-Critic with Parametric Policies for Linear Markov Decision Processes
- 2603.29765-Training-Free Dynamic Upcycling of Expert Language Models
- 2605.00778-Observable Performance Does Not Fully Reflect Adaptive System Organization: A Multi-Level Analysis of Gait Dynamics Under Occlusal Constraint
- 2605.06906-TraXion: Rethinking Pre-training Frameworks for Mobility and Beyond
- 2605.09165-Sparse Layers are Critical to Scaling Looped Language Models
- 2605.09439-Inverse Design for Conditional Distribution Matching
- 2605.10313-Signature Approach for Contextual Bandits with Nonlinear and Path-dependent Rewards: Regret Bound and Statistical Inference
- 2605.10878-Minimum Neural Weight Norm = Kolmogorov Complexity
- 2605.11617-MIST: Reliable Streaming Decision Trees for Online Class-Incremental Learning via McDiarmid Bound