This prompt is designed for conversational AI teams who need to verify that their assistant correctly tracks user intent as it evolves across multiple conversation turns. Single-turn intent classification misses critical failures: an assistant that correctly identifies 'book a flight' on turn one but treats 'actually, I want a train instead' on turn three as a new unrelated query has failed at intent tracking. The core job-to-be-done is automated, repeatable evaluation of intent tracking accuracy before shipping a new model, prompt, or conversation handler. The ideal user is an ML engineer, evaluation lead, or product engineer who has conversation transcripts with ground-truth intent labels and needs per-turn accuracy scores, drift flags, and actionable misclassification diagnoses without manually reviewing hundreds of sessions.
Prompt
Multi-Turn User Intent Tracking Accuracy Prompt

When to Use This Prompt
Understand the job this prompt solves, the required inputs, and the boundaries where it stops being the right tool.
To use this prompt effectively, you must provide three inputs: a full conversation transcript with turn-by-turn speaker labels, the assistant's inferred intent at each turn, and the ground-truth intent label sequence. The prompt acts as an LLM judge that compares inferred intents against ground truth, producing a structured evaluation payload that includes per-turn binary accuracy, intent drift detection when the assistant fails to follow a user's mid-conversation correction, and a diagnostic explanation for each misclassified turn. This is not a single-turn classification benchmark replacement—it specifically tests whether the assistant's intent model updates correctly when users change their minds, add constraints, or pivot goals mid-session.
Do not use this prompt when you lack ground-truth intent labels, when evaluating single-turn intent classifiers in isolation, or when the conversation contains ambiguous intent shifts that even human annotators would disagree on. The judge prompt assumes that ground-truth labels are authoritative; if your labeling process has low inter-annotator agreement, the evaluation scores will reflect label noise rather than model quality. For conversations where intent is genuinely ambiguous, pair this with a human calibration step or use the Multi-Turn Judge Alignment Verification Prompt to measure judge-human agreement before relying on automated scores. If you need to evaluate broader conversation quality beyond intent tracking—such as tone, safety, or groundedness—combine this prompt with the Multi-Turn Conversation Scorecard Generation Prompt for a unified quality report.
Use Case Fit
Where this prompt works and where it does not. Use these cards to decide if the Multi-Turn User Intent Tracking Accuracy Prompt fits your evaluation pipeline.
Good Fit: Structured Chat Logs with Ground Truth
Use when: you have complete conversation transcripts and labeled intent ground truth per turn. Guardrail: require a minimum of 3 turns per session and ensure intent labels follow a consistent taxonomy before running the prompt.
Bad Fit: Open-Ended Creative Dialogue
Avoid when: conversations are exploratory, social, or lack a defined intent taxonomy. Guardrail: if intent labels are ambiguous or overlapping, switch to a goal-completion or task-progress evaluation prompt instead.
Required Inputs: Transcripts and Intent Maps
What to watch: missing or misaligned turn indices between the transcript and ground-truth intent labels. Guardrail: validate input alignment with a pre-processing script that checks turn counts match before invoking the LLM judge.
Operational Risk: Intent Taxonomy Drift
What to watch: intent definitions changing between labeling runs, causing the judge to penalize correct but newly-named intents. Guardrail: version-lock your intent taxonomy and include taxonomy definitions in the prompt context to anchor scoring.
Operational Risk: Late-Breaking User Corrections
What to watch: users correcting their intent mid-conversation, which can look like tracking failure if ground truth only labels the final intent. Guardrail: label intent per turn, not per session, and flag correction turns separately in your ground truth schema.
Bad Fit: Single-Turn or Stateless Interactions
Avoid when: each user message is independent with no conversational history. Guardrail: use a single-turn intent classification accuracy prompt instead; multi-turn tracking adds unnecessary complexity and false-positive drift flags.
Copy-Ready Prompt Template
A copy-ready prompt for evaluating whether an assistant correctly tracks evolving user intent across multiple conversation turns.
This prompt template is designed to be pasted directly into your evaluation harness. It instructs the model to act as an evaluator, comparing the assistant's inferred intent at each turn against a set of ground-truth intent labels. The primary job is to detect intent loss, misinterpretation, and silent intent shifts that degrade conversation quality. The template uses square-bracket placeholders for all dynamic inputs, making it straightforward to integrate with your existing logging and evaluation infrastructure. Before using it, ensure you have a conversation log and a corresponding list of ground-truth intents for each user turn.
textYou are an expert evaluator of conversational AI systems. Your task is to assess how accurately an assistant tracks the user's evolving intent across a multi-turn conversation. You will be provided with: - A full conversation log between a user and an assistant. - A list of ground-truth user intent labels for each user turn. For each user turn in the conversation, you must: 1. Infer the user's primary intent based on the conversation history up to that point. 2. Compare your inferred intent with the provided ground-truth intent for that turn. 3. Assign a binary score: `true` if the inferred intent matches the ground-truth intent, `false` otherwise. 4. Provide a brief, evidence-based justification for your score, citing the specific user messages that support your inference. After evaluating all turns, produce a final summary including: - An overall intent tracking accuracy score (percentage of turns with a `true` match). - A list of turns where intent was lost or misinterpreted, with the ground-truth intent, the incorrectly inferred intent, and the justification. --- CONVERSATION LOG: [CONVERSATION_LOG] GROUND-TRUTH INTENTS (one per user turn, in order): [GROUND_TRUTH_INTENTS] OUTPUT_SCHEMA: { "turn_evaluations": [ { "turn_index": <integer>, "user_message": "<exact user text>", "ground_truth_intent": "<string>", "inferred_intent": "<string>", "intent_match": <boolean>, "justification": "<string>" } ], "overall_accuracy_score": <float between 0.0 and 1.0>, "misinterpreted_turns": [ { "turn_index": <integer>, "ground_truth_intent": "<string>", "inferred_intent": "<string>", "justification": "<string>" } ] } CONSTRAINTS: - Infer intent based on the entire conversation history, not just the current user message. - If the user's intent is ambiguous, state that in your justification and compare against the most likely interpretation. - Do not invent intents that are not present in the conversation. - The `overall_accuracy_score` must be calculated as the number of `true` matches divided by the total number of turns.
To adapt this template, replace the [CONVERSATION_LOG] and [GROUND_TRUTH_INTENTS] placeholders with your data. The conversation log should be formatted clearly, with each turn prefixed by 'User:' or 'Assistant:'. The ground-truth intents must be a list of strings, one for each user turn, in the exact order they appear. For high-stakes evaluations, such as those used in a CI/CD release gate, always pair this prompt with a post-processing validation step. This validator should check that the output is valid JSON, that the number of evaluated turns matches the input, and that the calculated accuracy score is mathematically correct. If the output fails validation, implement a retry with a more explicit instruction or escalate for human review to diagnose systematic evaluation errors.
Prompt Variables
Required inputs for the Multi-Turn User Intent Tracking Accuracy Prompt. Each placeholder must be populated before evaluation. Missing or malformed inputs cause the judge to produce unreliable scores.
| Placeholder | Purpose | Example | Validation Notes |
|---|---|---|---|
[CONVERSATION_TRANSCRIPT] | Full multi-turn conversation to evaluate, with turn indices and speaker labels | TURN_1_USER: Book a flight to Chicago TURN_1_ASST: Sure, what date? TURN_2_USER: Actually, make it a train | Must include at least 3 turns. Speaker labels must distinguish user from assistant. Parse check: verify turn count matches expected session length |
[GROUND_TRUTH_INTENTS] | Per-turn ground-truth intent labels for comparison against inferred intents | TURN_1: book_flight TURN_2: book_train TURN_3: modify_booking | Must align 1:1 with user turns in transcript. Schema check: intent labels must match allowed taxonomy. Null allowed for turns with no clear intent |
[INTENT_TAXONOMY] | Allowed intent label set the model must classify into | book_flight, book_train, cancel_booking, modify_booking, check_status, general_inquiry | Must be a non-empty list. Schema check: validate no duplicate labels. Taxonomy changes require re-baselining evaluation thresholds |
[INFERRED_INTENTS] | Model-predicted intents per turn to evaluate against ground truth | TURN_1: book_flight TURN_2: book_flight TURN_3: modify_booking | Must align 1:1 with user turns. Parse check: every turn index must have an intent or explicit null. Mismatched turn count triggers pre-evaluation rejection |
[INTENT_CHANGE_THRESHOLD] | Minimum confidence delta required to flag an intent shift as valid rather than noise | 0.7 | Must be float between 0.0 and 1.0. Validation rule: values below 0.5 produce excessive false-positive shift flags; values above 0.9 risk missing genuine corrections |
[CONTEXT_WINDOW_SIZE] | Number of prior turns the judge considers when evaluating whether intent tracking decayed | 5 | Must be positive integer. Parse check: reject non-integer values. Window larger than transcript length defaults to full transcript with warning |
[SCORING_RUBRIC] | Per-turn scoring criteria defining correct, partial, and missed intent tracking | correct: inferred matches ground truth exactly partial: inferred is sibling category missed: inferred is unrelated or null | Must define all three levels. Schema check: each level requires a non-empty description. Missing rubric levels cause judge to default to binary correct/incorrect scoring |
Implementation Harness Notes
How to wire the Multi-Turn User Intent Tracking Accuracy Prompt into an evaluation pipeline with validation, retries, and model selection.
This prompt is designed to operate as a batch evaluation step within a larger conversation quality pipeline, not as a real-time chat module. The harness should feed the prompt a complete conversation transcript, a list of ground-truth intent labels indexed by turn, and the assistant's inferred intents for the same turns. The model's job is to compare the inferred intent against the ground truth at each turn and produce a structured accuracy report. Because intent tracking is a high-signal metric for conversational AI teams, the harness must enforce strict output validation before accepting scores into your evaluation database.
Wire the prompt into an evaluation runner that iterates over a dataset of scored conversations. For each conversation, assemble the [CONVERSATION_TRANSCRIPT], [GROUND_TRUTH_INTENTS] (a JSON array of {turn_index, intent_label, description} objects), and [INFERRED_INTENTS] (the same structure, produced by your assistant or an upstream intent classifier). Pass these into the prompt template along with your [INTENT_TAXONOMY] and [MISINTERPRETATION_THRESHOLD]. Configure the model call with temperature=0 and a low top_p value to maximize deterministic scoring. Use a model with strong instruction-following and JSON output capabilities—GPT-4o, Claude 3.5 Sonnet, or equivalent. Request structured output matching the expected JSON schema: a per_turn_results array with turn_index, ground_truth_intent, inferred_intent, match (boolean), confidence (0-1), and misinterpretation_flag (boolean), plus a session_level_summary containing overall_accuracy, intent_loss_turns, and misinterpretation_turns.
After receiving the model response, validate the output before recording scores. Check that per_turn_results contains an entry for every turn in the ground-truth list, that match values are consistent with the intent comparison, and that overall_accuracy matches the computed ratio of matches to total turns. If validation fails, retry once with the same prompt plus the validation error message appended as a [CORRECTION_FEEDBACK] block. If the second attempt also fails validation, log the conversation as an eval failure and exclude it from aggregate metrics rather than accepting a potentially incorrect score. For high-stakes evaluations—such as pre-release quality gates or model selection decisions—route a sample of scored conversations to human reviewers for calibration. Store the raw prompt, model response, validation result, and any human override in your evaluation database for auditability and judge-alignment analysis over time.
Common failure modes in the harness include: the model swapping intent labels between turns when the conversation has rapid topic shifts, the model marking a match when the inferred intent is semantically close but not identical to the ground truth, and JSON parse failures when the output contains trailing text or markdown fences. Mitigate these by including explicit examples of near-miss intents in the [EXAMPLES] section of the prompt, by using strict JSON mode or structured output APIs where available, and by implementing a JSON repair step in the harness that strips markdown fences and trailing commas before parsing. Do not use this prompt for real-time intent correction during live conversations—it is an offline evaluation tool. For production intent tracking, implement a separate classifier with its own latency and reliability characteristics.
Expected Output Contract
Defines the strict JSON schema for the multi-turn intent tracking evaluation response. Use this contract to validate the LLM judge's output before ingesting scores into dashboards or CI pipelines.
| Field or Element | Type or Format | Required | Validation Rule |
|---|---|---|---|
session_id | string | Must match the [SESSION_ID] input exactly. Reject on mismatch. | |
evaluation_timestamp | ISO 8601 string | Must parse as valid ISO 8601 datetime. Reject if unparseable or in the future beyond a 5-minute clock skew tolerance. | |
overall_intent_tracking_score | number (0.0-1.0) | Must be a float between 0.0 and 1.0 inclusive. Reject if out of range or non-numeric. | |
turn_evaluations | array of objects | Array length must equal the number of turns in [TURN_HISTORY]. Reject on length mismatch. | |
turn_evaluations[].turn_index | integer | Must be a zero-indexed integer matching the turn's position in [TURN_HISTORY]. Reject on gaps, duplicates, or out-of-order indices. | |
turn_evaluations[].inferred_intent | string | Must be a non-empty string. Null or empty string is a schema violation. | |
turn_evaluations[].ground_truth_intent | string | Must exactly match the corresponding label in [GROUND_TRUTH_INTENTS]. Reject on mismatch to prevent label hallucination. | |
turn_evaluations[].intent_match | boolean | Must be true if inferred_intent equals ground_truth_intent, false otherwise. Reject if this boolean is inconsistent with the string comparison. |
Common Failure Modes
Multi-turn intent tracking fails in predictable ways. These are the most common failure modes when evaluating whether an assistant correctly tracks evolving user intent across turns, with practical guardrails to catch them before they reach production.
Intent Label Collapse Across Turns
What to watch: The evaluator assigns the same intent label to every turn, ignoring mid-conversation shifts. This happens when the prompt over-weights the session's opening intent and under-weights later corrections or topic changes. Guardrail: Require per-turn independent intent classification before session-level comparison. Add explicit instruction: 'Evaluate each turn's intent independently. Do not assume the initial intent persists.' Validate with synthetic conversations containing deliberate mid-session intent switches.
Ground-Truth Misalignment Drift
What to watch: The LLM judge's inferred intent labels drift away from human-annotated ground truth as conversations grow longer. Early turns match well; later turns diverge because the judge starts inferring intent from assistant responses rather than user utterances. Guardrail: Constrain the judge to evaluate intent from user messages only, not assistant replies. Include a strict instruction: 'Base intent inference solely on the user's words. Do not use the assistant's response to retroactively reinterpret what the user meant.' Run correlation checks per turn depth to detect drift.
Implicit Intent Blindness
What to watch: The evaluator misses implied intent shifts—when a user says 'Actually, can we go back?' or 'That's not what I meant' without restating the goal explicitly. The judge marks intent as unchanged when a human would recognize the correction. Guardrail: Add an explicit implicit-intent detection pass: 'Identify any turn where the user signals dissatisfaction, correction, or redirection without restating their goal. Flag these as potential intent shifts for separate review.' Calibrate against human annotations that include implicit shift labels.
Multi-Intent Turn Misattribution
What to watch: A single user turn contains multiple intents (e.g., 'Change my order and also check delivery time'), but the evaluator picks only one and ignores the rest. This produces false negatives when the assistant correctly handles the secondary intent but the judge marks it as missed. Guardrail: Allow multi-label intent assignment per turn. Structure the output schema to accept an array of intents per turn rather than a single label. Include a multi-intent detection instruction: 'If a turn contains more than one actionable intent, list all detected intents.'
Temporal Context Confusion
What to watch: The evaluator misjudges intent because it fails to track temporal references—'next week,' 'after that,' 'before we discussed X.' Intent labels become misaligned when the judge can't sequence user goals chronologically. Guardrail: Add a temporal anchoring step before intent classification: 'First, extract all temporal references and order them chronologically. Then assign intents with respect to this timeline.' Test with conversations containing relative time expressions and out-of-order goal references.
Overcorrection on Ambiguous Turns
What to watch: The evaluator flags intent changes on turns that are genuinely ambiguous or exploratory ('Hmm, I'm not sure...'), inflating false-positive intent-shift detections. This makes the tracking score noisy and unreliable for release gating. Guardrail: Add an ambiguity confidence threshold. Require the judge to output a confidence score per intent label and exclude low-confidence shifts from the primary accuracy calculation. Report ambiguous turns separately as 'unclassified' rather than forcing a label that pollutes the metric.
Evaluation Rubric
Use this rubric to test the Multi-Turn User Intent Tracking Accuracy Prompt before relying on it in production. Each criterion validates a specific failure mode of intent tracking across conversation turns.
| Criterion | Pass Standard | Failure Signal | Test Method |
|---|---|---|---|
Intent Label Match Rate | Inferred intent matches ground-truth label for at least 90% of turns in the test set | Match rate below 90%; frequent mismatches on turns following topic shifts or corrections | Run prompt against 50+ annotated multi-turn conversations; compute per-turn exact match rate |
Intent Loss Detection | Prompt correctly flags all turns where the assistant lost the user's stated intent | Missed intent-loss events; false positives on legitimate topic changes initiated by the user | Inject 10 conversations with known intent-loss turns; verify flag recall >= 95% and precision >= 85% |
Intent Misinterpretation Flagging | Prompt identifies turns where the assistant acted on a plausible but incorrect intent | Misinterpretation flags missing on turns with clear evidence of wrong intent; flags on correct interpretations | Use conversations with labeled misinterpretation events; check that flagging aligns with human annotations |
Turn Boundary Accuracy | Intent tracking scores are assigned to the correct turn indices without off-by-one errors | Scores shifted by one or more turns; intent attributed to the wrong user or assistant message | Validate turn index alignment against ground-truth turn numbering in 20 multi-turn sessions |
Context Window Robustness | Intent tracking remains accurate for conversations up to the prompt's stated max turn limit | Accuracy degrades significantly beyond 10 turns; earlier turns' intents are forgotten or overwritten | Test with conversations of 5, 10, 20, and 30 turns; measure accuracy drop-off curve |
Ambiguous Intent Handling | Prompt marks ambiguous turns with a confidence score below threshold rather than guessing | High-confidence incorrect labels on genuinely ambiguous user messages; no uncertainty signal | Feed 15 turns with deliberately ambiguous user inputs; verify confidence scores are below 0.7 for ambiguous cases |
Correction Incorporation | Prompt detects when the user corrects a misinterpreted intent and updates tracking accordingly | Intent tracking persists with the original incorrect intent after an explicit user correction | Insert mid-conversation corrections into 10 test sessions; verify intent label updates within 2 turns of correction |
Output Schema Compliance | Every response includes all required fields: turn_index, inferred_intent, ground_truth_intent, match, confidence, flags | Missing fields; extra fields; type mismatches; malformed JSON that fails schema validation | Validate all outputs against the defined JSON schema using an automated schema validator; 100% compliance required |
Enabling Efficiency, Speed & Accuracy
Intelligent Analysis, Decision & Execution
We build AI systems for teams that need search across company data, workflow automation across tools, or AI features inside products and internal software.
Talk to Us
Search across company data
Give teams answers from docs, tickets, runbooks, and product data with sources and permissions.
Useful when people spend too long searching or get different answers from different systems.

Automate internal workflows
Use AI to route work, draft outputs, trigger actions, and keep approvals and logs in place.
Useful when repetitive work moves across multiple tools and teams.

Add AI to products and internal tools
Build assistants, guided actions, or decision support into the software your team or customers already use.
Useful when AI needs to be part of the product, not a separate tool.
Adapt This Prompt
How to adapt
Start with the base prompt and a small set of 5-10 annotated conversations. Use a single LLM judge without calibration. Skip schema enforcement on the output—accept free-text JSON as long as it contains turn_scores, intent_loss_flags, and session_score. Run the prompt against conversations where you already know the intent labels and spot-check 3-5 sessions manually.
Simplify the input format: instead of full ground-truth intent labels per turn, provide a list of expected intents and ask the judge to match each turn to the closest intent. Drop the misinterpretation_type field until you've confirmed the base scoring logic works.
Watch for
- The judge assigning high scores to conversations where the assistant stayed on-topic but missed the actual intent shift
- Overly generous scoring when the assistant acknowledged the user without acting on the changed intent
- Missing
intent_loss_flagson turns where the user corrected the assistant but the assistant repeated the original intent

About the author
Prasad Kumkar
CEO & MD, Inference Systems
Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.
His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.
Partnered with leading AI, data, and software stack.
How We Work
Custom AI workflows for your Business
One-fit-all AI don't work for modern businesses. At Inferensys, we aim to understand your business & custom requirements; which we use to define most efficient agentic workflows, the data, and the tools for your business.
01
Review the use case
We understand the task, the users, and where AI can actually help.
Read more02
Pick the right approach
We define what needs search, automation, or product integration.
Read more03
Build the first useful version
We implement the part that proves the value first.
Read more04
Improve from there
We add the checks and visibility needed to keep it useful.
Read moreThe first call is a practical review of your use case and the right next step.
Talk to Us