Human conversation is inherently non-linear. We rarely follow a strict, pre-determined script; instead, we ask follow-up questions, change our minds mid-sentence, introduce digressions, or request immediate clarifications.
Early dialogue systems struggled with this fluid behavior because they relied on rigid finite-state machines (FSMs). In an FSM model, the conversation is mapped out like a flowchart. If a user veers off-script or provides unexpected input, the system typically breaks down, resulting in repetitive error prompts or catastrophic failure.
To build conversational agents capable of natural interaction, researchers shifted away from static flowcharts toward reactive planning and dynamic plan revision. Under this paradigm, a dialogue is treated as a live planning problem: the system maintains an internal agenda of conversational goals but continuously revises, interrupts, and threads the discourse structure in response to the user.
Shifting from Scripts to Plans
The foundational insight of this research direction is that user deviations should not be treated as errors. As Jullien et al. argued, conversational shifts are natural occurrences. Instead of forcing the user back into a rigid track, a dialogue manager must cooperatively adapt by structurally transforming its internal plan.
When a system's actions deviate from a user's expectations, the user will naturally initiate meta-communication, such as asking for repairs or clarifications (Dybkjær et al.). Managing these shifts gracefully is essential for maintaining a smooth user experience, particularly when a user's intentions or tasks change mid-conversation (Banchs et al.). Reactive planning achieves this by treating the dialogue structure as a malleable tree or stack that can be modified turn-by-turn.
Decoupling Content from Discourse Structure
To understand why reactive planning works, it helps to look at how these systems organize information. If a system mixes what it wants to say with how the conversation should flow, any user interruption forces the system to recalculate the entire interaction.
To solve this, Cawsey proposed a two-level planning architecture that cleanly decouples content planning (selecting what facts or concepts to explain) from dialogue planning (managing the turn-taking and interaction).
[ Content Pool: Facts & Goals ]
│
▼ (Selected dynamically)
[ Dialogue Planner: Incremental Steps ] ◄─── [ User Feedback / Interruptions ]
This separation enables incremental planning, where future conversational steps are not locked in upfront. Instead, the system plans only a few steps ahead, allowing it to adapt to user interruptions without needing a costly, full-system replan.
Similarly, Suthers et al. demonstrated that factoring content selection away from structural organization enables opportunistic planning. If a user signals confusion, the system can instantly pause its high-level explanation to insert a definition or sub-dialogue. By abandoning static templates in favor of reactive generation, the system ensures that explanations remain highly relevant to the user's changing knowledge level (Moore et al.).
The Mechanics of Dialogue Threading
When a user deviates from the expected path, how does the system structurally adapt without losing track of the original goal? The solution lies in tracking conversational state through an expectation stack and applying revision metaplans (Decitre et al.; Jullien et al.).
When the system detects that a user utterance deviates from the current expectation stack, it does not fail. Instead, it invokes a metaplan to structurally transform the dialogue tree. This transformation can happen in two ways:
- Local Adjustments: Embedding a temporary sub-dialogue (e.g., answering a quick clarification question) before returning to the main thread.
- Global Changes: Reordering the remaining topics entirely because the user's input made a future topic relevant out of order.
This process is often called dynamic dialogue threading. As Schultz et al. explained, dynamic threading allows a system to reshape conversation flows based on evolving needs. The dialogue manager can cleanly pause an active discussion thread to resolve a side-issue and then pop the original pedagogical or task goal back off the stack to resume the primary path exactly where it left off.
Reactive Operators for Real-Time Recovery
To execute these structural changes on the fly, systems utilize specialized, low-level dialogue operators within a "just-in-time" planning engine (Freedman). Rather than executing a static script, the planner evaluates the context after every single utterance and applies primitive operators to manipulate the active plan tree:
Retry-at: Allows the system to backtrack to a previous choice point. If a user changes their mind or introduces an inconsistency, the system can revert its state and re-interpret the input, avoiding repetitive and frustrating questioning (Coelho).Prune-replace: Cuts out a branch of the current plan that has become redundant or irrelevant due to the user's response, replacing it with a new set of goals.Fact: Evaluates conditional execution states in real time to see if a planned step is still necessary.
These operators are frequently paired with meta-rules that act as conditional interrupts. For example, Woolf et al. demonstrated how meta-rules can monitor a user's confusion threshold. If the threshold is crossed, the system immediately executes a strategy shift, abandoning a failing line of questioning in favor of a remedial explanation.
Managing Digression Severity and Redirection
Not all conversational deviations require the same response. The authors of A Dialogue System with Digression Handling – An Ontology-Based Approach (AAAI 2002) showed that systems can employ multi-level strategies based on the severity of a digression. For minor deviations, the system might simply steer the conversation gently back toward related topics using a structured ontology, while major deviations might be handled differently without triggering an immediate, computationally expensive replan.
When a user veers completely off-course, the system can also employ proactive redirection. Rather than failing or returning a generic error message, the system designed by Lee et al. proactively suggests transitioning to an entirely new, appropriate scenario, thereby maintaining conversational momentum.
Ultimately, by automatically adapting dialogue strategies based on user history and real-time input, systems become significantly more robust at resolving conversational anomalies, resulting in more efficient interactions and higher user satisfaction (Chu-Carroll).
Key Foundational Work
A Formalism for the Structural Analysis of Dialogues (1982) — contributed 2 concept elements to this direction.
Context-Dependent Transitions in Tutoring Discourse (1984) — contributed 1 concept elements to this direction.