Multi-Turn Dialogue

The component that estimates the user's goal and the current belief state at every turn. DST aggregates the dialogue history to maintain a probability distribution over possible user intents and slot-value pairs. Unlike simple history logging, DST actively interprets ambiguous inputs, resolving them against the established context. For example, when a user says 'the cheaper one' after discussing flights, DST maps this to a specific slot constraint (e.g., price_sort=asc) on the previously discussed entity. Modern approaches use generative DST, where a language model directly outputs the state as structured JSON rather than relying on predefined ontology lookups.

The NLP task of identifying all linguistic expressions that refer to the same real-world entity. In multi-turn dialogue, this resolves anaphora (e.g., 'it,' 'she,' 'that policy') and cataphora across turns. A robust system must link 'the account' in turn 4 back to 'checking account ending in 1234' mentioned in turn 1. Failure here causes entity confusion and incorrect API calls. Techniques include mention-ranking models and span-based architectures that score candidate antecedents based on syntactic, semantic, and positional features within the conversation history.

The engineering discipline of optimizing the token budget to prevent truncation and the Lost in the Middle phenomenon. Strategies include:

• Sliding Windows: Retaining the N most recent turns.
• Contextual Compression: Summarizing older turns using a secondary model to preserve intent while reducing token count.
• KV-Cache Optimization: Storing Key and Value tensors to avoid recomputing attention for static prefixes like the system prompt. Effective management prevents context collapse, where the model loses the distinction between different conversational threads.

The mechanism that allows a system to recognize that a follow-up utterance relates to a previously stated goal without the user restating it. For instance, after 'Book a flight to London,' the query 'Make it business class' carries over the intent=book_flight and destination=London. Slot filling extracts the new parameter (class=business) and merges it into the existing frame. This requires a multi-label intent classifier and a slot-gate that determines whether a slot should be updated, carried over, or cleared based on the new utterance.

The ability to fork a dialogue from a specific prior turn to explore alternative paths without corrupting the original session state. This is critical for A/B testing prompts, debugging agent loops, or allowing users to backtrack. Implementation relies on an immutable event log and a directed acyclic graph (DAG) of message nodes. Each branch maintains its own session state pointer. When a user says 'go back and try a different payment method,' the system creates a new branch from the payment selection node, preserving the original history for audit trails.

Safety filters that evaluate the full conversational context to block policy-violating prompts that are only harmful within a specific dialogue history. A simple keyword blocklist is insufficient; a statement like 'ignore previous instructions' is only dangerous when it follows a system prompt. Defenses include:

• Prompt Injection Boundary: Strict delimiters separating untrusted user input from trusted developer instructions.
• Context-Aware Classifiers: Models that flag anomalous intent shifts.
• Input Sanitization: Encoding user input to neutralize control characters before insertion into the context window.

A classic slot-filling pattern where the system gathers required parameters across turns.

• Turn 1: User: 'Book a flight to London.' System identifies intent but needs origin, date, and preferred airline.
• Turn 2: System asks: 'Where will you be departing from?' User: 'New York, JFK.'
• Turn 3: System asks: 'What date?' User: 'Next Tuesday.' System resolves 'next Tuesday' to a specific date using temporal grounding.
• Turn 4: System confirms all slots and executes the search.

This relies on Dialogue State Tracking (DST) to maintain a belief state of filled and unfilled slots.

A diagnostic dialogue where the system narrows a problem space through information-seeking turns.

• Turn 1: User: 'My deployment is failing.' System accesses session state to recall the user's recent CI/CD pipeline activity.
• Turn 2: System asks: 'Is this related to the payment-service container you pushed 10 minutes ago?' Uses coreference resolution to link 'deployment' to a prior event.
• Turn 3: User: 'Yes, it's throwing a 502.' System cross-references error logs and suggests checking the load balancer health check path.

This pattern prevents context drift by anchoring each turn to the original failure diagnosis goal.

An analytical dialogue where each turn refines a data query based on prior results.

• Turn 1: User: 'Show me Q3 revenue.' System returns a chart and stores the query parameters in the conversation history.
• Turn 2: User: 'Break it down by region.' System understands 'it' refers to Q3 revenue via anaphora resolution and applies the regional grouping.
• Turn 3: User: 'Exclude EMEA.' System filters the existing result set without re-querying the entire dataset, leveraging contextual compression.
• Turn 4: User: 'Compare to Q2.' System retrieves Q2 data and generates a delta, maintaining the regional and exclusion filters from prior turns.

This demonstrates intent carryover where each subsequent command inherits the constraints of the previous context.

A handoff pattern where conversational context is preserved when transferring between agents or systems.

• Turn 1-4: User interacts with a tier-1 bot to describe a billing dispute. The bot collects the order number, dispute reason, and screenshots.
• Turn 5: The bot determines escalation is required. It serializes the full dialogue state—including extracted entities and sentiment trajectory—into a structured payload.
• Turn 6: A human agent receives the ticket with the complete conversation history pre-loaded, avoiding the 'repeat yourself' frustration.

This relies on a distributed session store to externalize state so any agent node can resume the session seamlessly.

An iterative refinement dialogue where the system and user collaborate on a document.

• Turn 1: User: 'Draft a blog post about MCP protocol.' System generates a draft and stores it in the session state.
• Turn 2: User: 'Make the intro more technical.' System identifies the introduction section and rewrites it with higher technical density, leaving the rest unchanged.
• Turn 3: User: 'Add a code example in Python.' System inserts a code block at the appropriate location, understanding document structure from prior context.
• Turn 4: User: 'Shorten the whole thing by 200 words.' System applies a global edit while preserving the Python example and technical tone.

This pattern uses conversation branching if the user wants to explore alternative versions without losing the original draft.

A preference-elicitation dialogue that narrows a product catalog through constraint-based filtering.

• Turn 1: User: 'I need running shoes.' System presents top-rated options and stores the category.
• Turn 2: User: 'For trail running, under $150.' System applies filters for terrain type and price range to the existing search.
• Turn 3: User: 'What about the blue ones from the second row?' System resolves 'the blue ones' to a specific SKU using visual grounding and dialogue history.
• Turn 4: User: 'Add to cart.' System executes the action on the resolved product without re-identification.

This demonstrates slot filling combined with coreference resolution across both text and visual modalities.