Groundedness: The One Metric That Actually Stops Hallucination

Relevant and wrong at the same time

Here is the failure that survives most RAG evaluation. A user asks a question, the system retrieves some documents, and the model produces an answer that is fluent, on-topic, and directly responsive, it scores beautifully on answer relevance. It is also partly invented: one sentence states a figure that appears in none of the retrieved documents, smoothly blended in among the supported ones. Relevance can’t catch this, because the fabricated sentence is just as relevant to the question as the true ones. Relevance measures whether you answered the right question, not whether the answer is real.

Groundedness is the metric built for exactly this gap. It evaluates whether the generated output is factually consistent with the retrieved documents, and a high groundedness score means the model is much less likely to be hallucinating (Future AGI, RAG Evaluation Metrics). Where relevance asks “did you address the question, ” groundedness asks “is every part of this answer actually supported by the evidence you were given.” For any system that makes factual claims, that second question is the one that maps to liability.

How groundedness is actually computed

The strength of groundedness as a metric is that it has a precise, mechanical definition, it isn’t a vibe. The standard operationalization uses natural language inference (NLI): decompose the response into atomic claims and classify each as entailed, neutral, or contradicted by the retrieved context, treating the answer as grounded only when the entailment ratio clears a high bar, thresholds above 0.9 are the common cut-off for “grounded” (Future AGI, RAG Evaluation Metrics Guide).

This claim-decomposition approach is also what the RAGAS framework and the “RAG triad” formalize: an LLM-as-judge (or NLI model) extracts each claim from the answer, checks it against the source documents, and tracks the ratio of supported to total claims (Confident AI, RAG Evaluation Metrics). The atomicity is what makes it powerful: a paragraph-level “does this look supported?” check misses the single fabricated clause; a claim-level check catches it because that clause gets its own entailment verdict.

A note on groundedness vs. faithfulness

The terms are often used interchangeably, but there’s a useful distinction. Groundedness emphasizes traceability, each claim links to a source span, frequently visualized as an attribution map. Faithfulness emphasizes the inverse, actively identifying distortions and unsupported claims. In practice you want both views: groundedness tells you what fraction of the answer is anchored, and the faithfulness lens tells you precisely which clauses are floating free.

Implementing the groundedness gate

# Groundedness via atomic-claim NLI, the RAGAS / RAG-triad pattern
def groundedness(answer, retrieved_context):
    claims = extract_atomic_claims(answer)          # one checkable fact per claim
    verdicts = []
    for claim in claims:
        # Classify each claim against the retrieved evidence
        v = nli_classify(premise=retrieved_context, hypothesis=claim)
        verdicts.append(v)                          # 'entailed' | 'neutral' | 'contradicted'

    n = max(len(claims), 1)
    entailed     = sum(v == 'entailed'     for v in verdicts) / n
    contradicted = sum(v == 'contradicted' for v in verdicts) / n
    return {
        'groundedness':   entailed,                 # supported / total claims
        'contradiction':  contradicted,             # actively wrong vs. source
        'ungrounded_claims': [c for c, v in zip(claims, verdicts) if v != 'entailed'],
    }

def is_grounded(answer, context, threshold=0.9):
    g = groundedness(answer, context)
    # A contradicted claim is a hard fail regardless of overall ratio
    return g['groundedness'] >= threshold and g['contradiction'] == 0

That contradiction == 0 guard matters. A neutral (unsupported) claim is a hallucination; a contradicted claim is the model stating the opposite of its own source, which is the most damaging failure of all and should never pass at any ratio.

# Use it both as a CI gate and a live production guard
def release_gate(model, golden_set):
    rates = [is_grounded(model(c.input), c.context) for c in golden_set]
    grounded_rate = sum(rates) / len(rates)
    assert grounded_rate >= 0.98, f"groundedness regressed: {grounded_rate:.1%}"

def production_guard(answer, context):
    g = groundedness(answer, context)
    if g['groundedness'] < 0.9 or g['contradiction'] > 0:
        # Don't serve a fabricated claim, strip it, refuse, or fall back
        return handle_ungrounded(answer, g['ungrounded_claims'])
    return answer

Why this is the one metric to gate on

If you could enforce a single property on a fact-bearing AI system, groundedness is the one with the highest leverage, for three reasons. First, it directly targets the failure with the worst consequences, the confident fabrication that causes the Air-Canada-style liability. Second, it’s measurable and thresholdable, so it can be a hard CI gate rather than a judgment call. Third, it generalizes: groundedness applies to RAG answers, to summaries, to tool-augmented agents, anywhere the output is supposed to derive from a source, the same atomic-claim entailment check works.

The failure modes groundedness still has to handle carefully

Groundedness is powerful, but it’s not free of edge cases, and a naive implementation will either miss real hallucinations or flag good answers. Three deserve explicit handling. First, claim decomposition quality: if you split the answer into claims badly, too coarsely, so a sentence with one true and one false clause is judged as a single unit, you’ll mark a partly-fabricated sentence as entailed. The atomicity of the decomposition is doing most of the work; invest in it.

Second, implicit and aggregated claims: an answer that says “the three reports agree” makes a claim about the relationship between sources that no single span states. Your entailment check has to consider the full retrieved set, not just look for one matching passage, or it will false-flag legitimate synthesis. Third, common-knowledge claims: “water boils at 100°C” may not appear in the retrieved context yet isn’t a hallucination. Strict groundedness flags it; whether that’s correct depends on your domain. In a regulated setting, requiring even common knowledge to be sourced is defensible; in a casual one, it’s annoying. Decide the policy explicitly rather than letting the metric decide it for you.

The bottom line

Relevance feels like the natural quality metric and it quietly lets fabrications through, because an invented claim is just as relevant as a true one. Groundedness is the metric that actually stops hallucination: decompose the answer into atomic claims, classify each as entailed, neutral, or contradicted by the retrieved evidence, require the entailment ratio above ~0.9, and treat any contradiction as a hard fail. Frameworks like RAGAS and the RAG triad give you the implementation. Gate releases on it, guard production with it, and an ungrounded claim becomes a blocked build instead of a customer-facing liability. Of every metric in the eval stack, this is the one that maps directly to whether your AI is making things up.