Correctness in LLM evaluation

Why exact match fails, and what replaces it

The obvious automation — string comparison against the reference — fails immediately on natural language. "14 days", "fourteen days" and "two weeks" are the same answer and share no characters. Exact match systematically punishes fluent phrasing.

The n-gram metrics inherited from translation (BLEU, ROUGE) are only a partial improvement: they reward surface overlap, so a wrong answer phrased like the reference can outscore a right answer phrased differently. They remain in use because they are cheap and deterministic, and they should not be trusted as a primary signal for factual correctness.

What works is claim-level judging: decompose both the answer and the reference into atomic facts, then check each answer claim against the reference. That handles paraphrase, gives partial credit, and tells you which fact was wrong — which a single similarity score never will.

The failure this dimension exists to catch

The important case is the grounded but wrong answer. The model faithfully reports what a retrieved document says, and that document is out of date, contradicted by a newer one, or simply mistaken.

Groundedness scores this perfectly. Relevance scores it perfectly. The answer is fluent, cited, and misinforms the user. No amount of prompt engineering fixes it, because the model did exactly what it was asked; the corpus is the defect.

That makes correctness the dimension that audits your data rather than your model. When correctness is low while groundedness is high, stop looking at the pipeline and go and look at the documents: stale versions, superseded policies, and duplicate chunks disagreeing with each other are the usual culprits.

Judging it without fooling yourself

Show the judge the reference. A model asked "is this answer correct?" with no ground truth is being asked to recall the fact itself, and will confidently score wrong answers as right in exactly the domains where you needed evaluation most.

Ask for partial credit. Binary correct/incorrect throws away the difference between an answer with one wrong detail and one that is entirely wrong. Per-claim scoring gives a proportion.

Calibrate against humans. Have annotators label a sample and measure agreement with your judge. If the judge agrees 70% of the time, a 3-point movement in your correctness score is noise.

Watch for self-preference. A judge tends to favour answers written in its own style, and to prefer longer answers. Both biases are documented and both inflate scores in ways that have nothing to do with being right.

Is the answer right?

Correctness compares the model's answer against a known ground truth. It is the metric stakeholders care about, and the hardest of the RAG metrics to measure well — because natural language has many correct forms.

Question: "How long is parental leave?"

Truth: "39 weeks, of which 6 are at full pay."

Answer A: "You get 39 weeks, with the first 6 paid in full." — correct

Answer B: "Thirty-nine weeks." — correct but incomplete

Answer C: "39 weeks at full pay." — wrong in a detail that matters

Exact string matching marks all three wrong. That is why correctness is usually scored by a model or a human rather than by comparison.

The methods, in ascending order of cost and quality:

Model-as-judge, done carefully

Asking a model to grade another model's answer works well enough to be the standard approach, and it needs care to be trustworthy.

Question: {question}
Reference answer: {truth}
Model answer: {answer}

Does the model answer convey the same information as the reference?
Ignore differences in wording, length and style. Note any factual
contradiction or missing essential detail.

Reply with JSON: {"verdict": "correct" | "partially_correct" | "incorrect",
                  "reason": "<one sentence>"}

Four practices separate a useful judge from a noisy one:

Give it the reference answer. Judging correctness without a ground truth is asking the model to know the answer, which reintroduces the problem you were measuring.

Use a discrete scale. Three or four labels are far more consistent than a 1–10 score, where models cluster around 7 and 8.

Require a reason. It improves consistency and makes disagreements auditable.

Validate against humans on a sample. Grade 50 answers manually and measure agreement with the judge. Below about 80% agreement, the judge's absolute numbers are not usable — though relative comparisons between configurations may still be.

Known biases to guard against: judges prefer longer answers, prefer answers from the same model family, and are sensitive to the order in which candidates are presented. Randomising order and controlling for length help.

Correctness against groundedness

These are different questions and the pair is diagnostic:

The third row is the one that looks like success and is not. A system that answers correctly from the model's own memory rather than from the retrieved documents will fail silently as soon as a question moves outside what the model happened to memorise — and no amount of testing on well-known facts will reveal it.

Measuring both is therefore not redundant. Groundedness tells you whether the system is using its sources; correctness tells you whether the result is right.

Why string matching fails, and what the judge costs

Correctness needs a reference answer, and comparing free text to a reference is harder than it sounds. This scores the same answers three ways -- exact match, token overlap, and a judge -- and shows exactly which kinds of answer each one gets wrong.

import numpy as np

REFERENCE = "Refunds are available within 30 days of purchase."

ANSWERS = [
    ("You have 30 days from purchase to request a refund.", True),
    ("Refunds are available within 30 days of purchase.", True),
    ("Within 30 days.", True),
    ("Refunds are available within 60 days of purchase.", False),
    ("Refunds are available within 30 days of purchase, and shipping "
     "is free.", True),
    ("The refund policy is described in section 4.", False),
]

def toks(s):
    return set(w.strip(".,").lower() for w in s.split())

REF = toks(REFERENCE)

def exact(a):
    return 1.0 if a.strip().lower() == REFERENCE.strip().lower() else 0.0

def f1(a):
    t = toks(a)
    if not t or not REF:
        return 0.0
    inter = len(t & REF)
    if not inter:
        return 0.0
    p, r = inter / float(len(t)), inter / float(len(REF))
    return 2 * p * r / (p + r)

print("THE REFERENCE ANSWER: %r" % REFERENCE)
print()
print("%-58s %8s %8s %8s" % ("candidate answer", "truth", "exact", "F1"))
for a, truth in ANSWERS:
    print("%-58s %8s %8.2f %8.4f"
          % (a[:56], "right" if truth else "WRONG", exact(a), f1(a)))
print()

print("EXACT MATCH scores %d of %d correctly."
      % (sum(1 for a, t in ANSWERS if (exact(a) >= 0.5) == t), len(ANSWERS)))
print("   it accepts only the reference itself. every correct paraphrase")
print("   is marked wrong, which means the metric is measuring whether")
print("   the model reproduced your wording, not whether it answered.")
print("   for anything but a single-token answer -- a date, a name, a")
print("   yes/no -- exact match is not an option.")
print()

THR = 0.5
print("TOKEN F1 at a threshold of %.1f scores %d of %d correctly."
      % (THR, sum(1 for a, t in ANSWERS if (f1(a) >= THR) == t), len(ANSWERS)))
print("   it handles paraphrase better, and it has two failure modes that")
print("   are both visible above:")
wrong_high = [(a, f1(a)) for a, t in ANSWERS if not t and f1(a) >= THR]
right_low = [(a, f1(a)) for a, t in ANSWERS if t and f1(a) < THR]
for a, s in wrong_high:
    print("      SCORES HIGH AND IS WRONG (%.4f):" % s)
    print("         %s" % a[:60])
for a, s in right_low:
    print("      SCORES LOW AND IS RIGHT (%.4f):" % s)
    print("         %s" % a[:60])
print("   the first is the serious one. '60 days' shares every word with")
print("   the reference except the one that carries the answer, so overlap")
print("   scores it %.4f -- higher than several correct answers."
      % f1("Refunds are available within 60 days of purchase."))
print("   token overlap cannot weight the token that matters, because it")
print("   does not know which token that is.")
print()

print("A MODEL-AS-JUDGE reads both and decides. this snippet cannot run")
print("one -- which is precisely the point, because a judge needs a model")
print("call per example and the two metrics above need none.")
print("a judge handles the '60 days' case that overlap could not, because")
print("it can tell which token carried the answer. it also brings its own")
print("problems, and they are not the obvious ones:")
print("%-34s %s" % ("problem", "what to do about it"))
for row in (("it is not deterministic", "temperature 0, and still sample"),
            ("it prefers longer answers", "control for length in the prompt"),
            ("it prefers its own family's style", "use a different family"),
            ("it agrees with itself, not you", "calibrate against humans once"),
            ("it costs a call per example", "sample, do not score everything")):
    print("%-34s %s" % row)
print("   the length bias is worth measuring on your own judge before")
print("   trusting it. score the same correct answer padded to different")
print("   lengths and see whether the number moves; if it does, your")
print("   'correctness' metric is partly a verbosity metric.")
print()

print("AND THE DISTINCTION THAT MATTERS MOST -- CORRECTNESS IS NOT")
print("GROUNDEDNESS:")
CASES = [
    ("the context is right, the answer follows it", "grounded", "correct"),
    ("the context is WRONG, the answer follows it", "grounded", "WRONG"),
    ("the context is right, the answer ignores it", "UNGROUNDED", "correct"),
    ("the context is right, the answer invents", "UNGROUNDED", "WRONG"),
]
print("%-46s %14s %10s" % ("situation", "groundedness", "correctness"))
for s, g, c in CASES:
    print("%-46s %14s %10s" % (s, g, c))
print("   row 2 is the one that catches teams out: a perfectly grounded")
print("   answer that is wrong, because the retrieved document was out of")
print("   date. groundedness cannot see it -- the answer faithfully")
print("   reflects the context it was given.")
print("   row 3 is the mirror: the model happened to know the answer and")
print("   ignored your documents. it looks correct and your retrieval is")
print("   doing nothing, which you will discover the first time the")
print("   question is about something the model was not trained on.")
print("   only correctness catches row 2, and only groundedness catches")
print("   row 3, which is why both get reported.")

Things to try

1. Click the digital-goods claim to mark it supported by the context. Groundedness rises to 1.0 and correctness does not move — it is still contradicted by the reference.
2. That single claim is the grounded-but-wrong case: cited, confident, and misinforming. It is why correctness cannot be inferred from the context.
3. Compare correctness with completeness. An answer can state only true things and still omit half of what was asked.

What to remember

Correctness compares the answer against a reference or verifiable fact, which makes it the only one of the four dimensions that requires ground truth someone has to write. Exact match and n-gram overlap fail on paraphrase; claim-level judging against a key-facts reference is what works. Its distinctive value is catching the grounded-but-wrong answer, where the model faithfully reports a document that is itself out of date — a defect in your corpus that every other dimension scores as a success.

These four are usually measured with an LLM as judge: a strong model is shown the question, the retrieved context, the answer and sometimes a reference, and asked to score one dimension at a time. Judging one dimension per call is not a stylistic choice — a single prompt asking for all four produces correlated, mushy scores, because the model settles on a general impression and applies it everywhere.

Two habits make judge scores trustworthy. Ask for a decision and a justification, so a human can audit disagreements. And calibrate against a small human-labelled set before believing any of it — a judge that agrees with your annotators 70% of the time is not measuring what you think it is measuring.

Building the evaluation set

Correctness needs ground truth, and where it comes from determines what the number means.

Hand-written by domain experts. Highest quality. 50 questions with careful reference answers is enough to catch regressions; 200 gives stable comparisons.

Derived from existing content. FAQ pairs, resolved support tickets, previously answered queries. Realistic and cheap where they exist.

Generated then reviewed. A model drafts questions and answers from the documents, a human corrects them. The pragmatic route for a new system, and the review step is not optional — unreviewed generated ground truth encodes the generator's errors.

Three things to include deliberately:

Unanswerable questions, where the corpus genuinely does not contain the answer. The correct response is a refusal, and measuring whether the system refuses is as important as measuring whether it answers.

Multi-hop questions requiring two documents. These fail differently and are where most systems are weakest.

Adversarial cases — questions with a false premise, ambiguous questions, questions whose answer changed between document versions.

What correctness does not tell you

Where the failure was. A wrong answer might be a retrieval failure, a prompt failure or a model failure. Correctness alone cannot say, which is why retrieval metrics are measured separately.

Whether the answer was useful. A technically correct answer can be unhelpful — too terse, badly structured, not addressing what was actually asked. Relevance and completeness cover that.

How it behaves on the questions you did not test. A 200-question evaluation set is a sample, and real traffic is broader and stranger.

Whether it is calibrated. A system that is 80% correct and confident every time is more dangerous than one that is 80% correct and flags its uncertainty.

So correctness sits in a suite alongside groundedness, relevance, completeness and refusal rate — not on its own.

Running it as a regression suite

The practical value comes from automation, not from a one-off measurement.

Run it on every change — chunk size, embedding model, prompt wording, model version. Each of those can move correctness, and without a suite the movement is invisible.

Fix the seed and temperature 0 so a difference between runs is a real difference.

Track per-question results, not just the aggregate. A change that fixes ten questions and breaks eight looks like a small improvement and is worth understanding.

Keep a hard subset of questions the system has failed before, as a regression guard.

Version the evaluation set and record which version produced each score, or comparisons across time become meaningless.

Questions people ask

How many questions do I need? 50 to catch large regressions, 200 for stable comparison between similar configurations.

Can I trust a model as judge? For relative comparisons, generally yes. For absolute numbers, validate against human grading on a sample first.

Should I use exact match? Only for short extracted values — dates, amounts, identifiers. It fails on anything free-form.

What about answers that are correct but incomplete? Use a three-level scale, or measure completeness as a separate metric.

How do I handle questions with several valid answers? Provide several reference answers and accept a match against any.

Should the judge be the same model being evaluated? Preferably not — self-preference bias is documented. Use a different model, or a human sample.

Recap in one screen

• Correctness compares the answer against known ground truth, and exact matching fails on free-form text.
• Model-as-judge is the practical default: give it the reference, use a discrete scale, require a reason, validate against humans.
• Correct-but-ungrounded is a warning, not a success — the system answered from memory.
• Include unanswerable, multi-hop and adversarial questions in the set.
• Run it as a versioned regression suite at temperature 0, tracking per-question results.