Building a task-oriented dialogue system traditionally resembles assembling a complex factory pipeline. You need one module for Natural Language Understanding (NLU) to parse user intent, another for Dialogue State Tracking (DST) to maintain a running log of user constraints, a third for Dialogue Policy to decide the system's next move, and a final Natural Language Generation (NLG) module to write the actual response.
As noted by Hongshen Chen et al. in their survey on dialogue systems, this modular design suffers from a fundamental flaw: error propagation. If the NLU module misinterprets a single word, that error cascades down the line, causing the state tracker to corrupt the history and the policy module to make an irrelevant decision. To eliminate these brittle boundaries, researchers shifted toward end-to-end neural architectures that map conversation history directly to a response (Jianfeng Gao et al., Open-Domain Neural Dialogue Systems). The culmination of this shift is session-level sequence modeling—an elegant approach that treats an entire dialogue session, including its internal logic, as a single continuous text-continuation task.
Dialogue as Text Continuation
Why treat dialogue as a sequence-to-sequence translation task when you can treat it as a text continuation problem? Early sequence-to-sequence models framed dialogue as mapping an input turn to an output turn, much like translating English to French. However, this ignores the holistic flow of human conversation.
Alessandro Sordoni (A Neural Network Approach to Context-Sensitive Generation of Conversational Responses) demonstrated that concatenating context, message, and response into a single continuous string allows a language model to naturally capture cross-turn dependencies. By moving away from the translation metaphor, the system treats the entire interaction history and the current response as a unified language modeling task (Hongyuan Mei et al., Coherent Dialogue with Attention-Based Language Models).
When a query and its response are modeled as a single stream, the model utilizes a shared self-attention mechanism across the entire sequence (Piji Li et al., Relevance-Promoting Language Model for Short-Text Conversation). Instead of encoding the history into a fixed bottleneck vector and decoding a response, the model simply predicts the next token in an ever-evolving sequence, allowing it to dynamically attend to any point in the conversation's past.
Serializing State and Logic
While text continuation works well for open-domain social chat, task-oriented dialogue requires structured reasoning. An assistant must track slot-value pairs (e.g., food: Italian, area: center) and interact with external databases. How can a monolithic language model handle this without specialized modules?
The solution is token serialization. Instead of separating text from metadata, the entire session state—user utterances, belief states, database query results, and system actions—is formatted as text strings and concatenated into a single sequence. Pawel Budzianowski et al. (Hello, It's GPT-2 - How Can I Help You? Towards the Use of Pretrained Language Models for Task-Oriented Dialogue Systems) showed that large generative language models can implicitly learn dialogue management and task logic simply by autoregressively predicting this unified sequence.
Consider how a single turn is structured in frameworks like SimpleTOD (Ehsan Hosseini-Asl et al., A Simple Language Model for Task-Oriented Dialogue):
[User] I'd like an Italian restaurant.
[Belief State] restaurant food Italian
[DB Result] match 3 restaurants found
[System Action] restaurant offer_name
[Response] I found 3 Italian restaurants. Would you like their names?
By training a single causal language model on this exact sequence format, the model performs all stages of the dialogue pipeline in a single autoregressive pass. As DongHoon Ham et al. (End-to-End Neural Pipeline for Goal-Oriented Dialogue Systems using GPT-2) point out, this sequence design preserves interpretability. Even though the architecture is a "black-box" neural network, developers can inspect the generated intermediate tokens (the belief states and system actions) before the final response is produced, making it easy to trace exactly where a tracking or policy error occurred.
Why Session-Level Modeling Prevents Conversational Drift
Early end-to-end models still suffered from myopia because they were trained on isolated, turn-by-turn pairs. In contrast, session-level sequence modeling trains the language model on the entire history of a multi-turn conversation at once (Yunyi Yang et al., UBAR: Towards Fully End-to-End Task-Oriented Dialog Systems with GPT-2).
This distinction is crucial for understanding why the approach works. When a model is optimized across an entire session sequence, self-attention learns the long-term trajectories and strategic planning required to achieve a goal. It captures the interdependencies between early conversational choices and late-stage task completion.
This global perspective is equally powerful when generating synthetic dialogue data. Traditional data augmentation relies on multi-agent simulations, where two independent models (a user agent and a system agent) chat turn-by-turn. However, multi-agent systems frequently suffer from conversational drift, where small deviations cause the agents to fall into repetitive, unnatural loops.
To solve this, Chujie Zheng et al. (AugESC: Dialogue Augmentation with Large Language Models for Emotional Support Conversation) and Suyeon Lee et al. (Cactus: Towards Psychological Counseling Conversations using Cognitive Behavioral Theory) proposed generating entire multi-turn dialogue scripts using a single high-capacity model via text completion. Because a single model generates the entire session sequence, it maintains a unified perspective on the interaction's narrative arc. This global consistency ensures that the conversational flow remains natural, coherent, and aligned with long-term objectives from the first turn to the last.
Key Foundational Work
Coherent Dialogue with Attention-Based Language Models (2017) — contributed 2 concept elements to this direction.