Inferensys

Prompt

Multi-Turn User Intent Tracking Accuracy Prompt

A practical prompt playbook for evaluating whether an assistant correctly tracks evolving user intent across conversation turns, using ground-truth labels and model-graded scoring.
Developer demonstrating multi-agent tool use, agent tool selection interface on laptop, casual tech demo moment.
PROMPT PLAYBOOK

When to Use This Prompt

Understand the job this prompt solves, the required inputs, and the boundaries where it stops being the right tool.

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.

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.

PRACTICAL GUARDRAILS

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.

01

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.

02

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.

03

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.

04

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.

05

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.

06

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.

PROMPT PLAYBOOK

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.

text
You 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.

IMPLEMENTATION TABLE

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.

PlaceholderPurposeExampleValidation 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

PROMPT PLAYBOOK

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.

IMPLEMENTATION TABLE

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 ElementType or FormatRequiredValidation 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.

PRACTICAL GUARDRAILS

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.

01

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.

02

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.

03

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.

04

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.'

05

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.

06

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.

IMPLEMENTATION TABLE

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.

CriterionPass StandardFailure SignalTest 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

ADAPTATION OPTIONS

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_flags on turns where the user corrected the assistant but the assistant repeated the original intent
Prasad Kumkar

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.