LLM Evaluation Without Ground Truth: What You Can Measure
Reference-free methods measure consistency and constraint satisfaction. Neither is correctness, and treating them as correctness ships confidently wrong systems.
AI-drafted, reviewed by Muhammad Qasim Hammad on October 3, 2026. See our AI disclosure.
Table of contents
You have 8,000 outputs, no labels, and no appetite for a labelling project. LLM evaluation without ground truth is possible and it does not measure what people assume it measures. It measures consistency and constraint satisfaction, which are useful and are not correctness, and treating them as correctness is how confidently wrong systems reach production.
What can you actually measure with no labels?#
Three families of signal. Whether the system agrees with itself across repeated or rephrased attempts, whether the output satisfies rules you can check mechanically, and whether people downstream accepted it. None requires a labelled set, and all three catch real failures the day you turn them on.
Constraint checks are the cheapest and the most underrated. Did it return valid structured output, did the value fall in the allowed set, did every cited claim point at a document that exists, did it stay inside the length you asked for. These are ordinary assertions and they fail loudly, which makes them the fastest thing to add.
Consistency checks cost more because they need extra calls. Sample the same input several times and see whether the answers agree, or paraphrase the input and see whether the answer survives the rewording. A system that gives 3 different answers to the same question is unreliable regardless of which one was right.
Production acceptance is the strongest of the three and the slowest to arrive. If a person edited the draft, overrode the label, or asked again in different words, that is evidence without anybody grading anything. It arrives only after launch, which is why the first two families matter before it.
Why is consistency not correctness?#
Because a system can be reliably wrong. A model that misreads the same field on every invoice from one supplier is perfectly consistent, satisfies every schema check, and is wrong every time. Consistency measures variance, and a bias sits in the mean where variance cannot see it.
This is the failure that reference-free evaluation cannot fix, and it is worth being blunt about because the metrics look so healthy while it happens. High agreement across samples, clean structured output and no refusals describe a system that is stable. Stability is a precondition for being right and is not evidence of it.
| What you measure | What it proves | What it misses |
|---|---|---|
| Agreement across samples | Low variance | A consistent bias |
| Schema and range checks | Well formed output | Well formed and wrong |
| Paraphrase invariance | Not prompt-brittle | Wrong under every phrasing |
| Citation resolves | The source exists | The source does not support it |
| Downstream acceptance | Someone did not object | Nobody checked carefully |
There is a partial defence, and it is worth building because it costs little. Constraint checks catch consistent bias whenever the bias produces something checkable: a total that does not equal the sum of its lines, a date outside the document's range, a cited passage that does not contain the claim. These are not correctness checks, but they convert a class of silent wrongness into a loud failure, which is the trade worth making everywhere.
The practical consequence is a small labelled set is still required eventually, and it can be very small. A few dozen carefully chosen cases, especially the ones you already argue about, anchor everything else. Reference-free methods then scale that judgement across volume you could never label.
What does production give you for free?#
Corrections, re-asks and abandonment, all already in your logs. A support answer followed by the same customer rephrasing the question is a failure signal nobody had to create. An extracted value that a person changed before saving is a labelled example that labelled itself.
Harvest those into the eval set rather than only counting them. Every correction is a case where you know the model's answer and the preferred answer, which is exactly the shape of a labelled example. Teams that do this find their eval set grows on its own and stays representative, because it is drawn from real traffic rather than imagined traffic.
The bias in that harvest is worth naming. Corrections come only from cases somebody looked at, so a set built purely from them over-represents the visible work and under-represents whatever runs unwatched. Mix in random samples to keep it honest.
Why compare pairs instead of scoring?#
Because absolute scores are not stable and comparisons are. Asking for a rating out of 10 produces numbers that drift between runs, cluster in the middle, and mean different things on different days. Asking which of two outputs is better is an easier question and the answers hold up far better across repeats.
Pairwise comparison also fits the decision you are usually making. You are rarely asking whether an output is good in the abstract; you are asking whether the new prompt beats the current one. A comparison answers that directly, and it needs no scale, no rubric calibration and no agreement on what a 7 means.
One structural warning applies to both approaches equally. If the same model family generates the output and evaluates it, the evaluation shares the generator's blind spots, and a mistake both of them make is invisible by construction. Using a different family for judging reduces this and does not eliminate it, which is another reason the small hand-judged set never fully goes away.
Two cautions carry over from judging generally. Position matters, so alternate which candidate appears first and count both orders. And a model asked to compare will show preferences that have nothing to do with quality, including for its own family's output, which the pitfalls of using a model as a judge covers in detail.
When do you have to stop and label?#
When the decision is expensive and reversible only at cost, or when consistency has stopped discriminating between your options. If two prompts are equally stable, equally well formed and equally accepted, reference-free evaluation has told you everything it can, and the remaining question is which is more often right.
The good news is the labelled set needed at that point is far smaller than the one you avoided at the start. You are no longer trying to measure a system, only to break a tie between 2 candidates on cases that are genuinely contested. Fifty well-chosen examples usually settle it, and building that set when you have few real ones is a solved problem.
Frequently asked questions
Can you evaluate an LLM system without labelled data?
Why is consistency not the same as accuracy?
What free evaluation signals already exist in production?
Should I score outputs or compare them in pairs?
When do I finally need labelled data?
Written by
Muhammad Qasim Hammad is an AI agent and automation expert and the founder of Cart Gaze LLC (cartgaze.com). He builds product for the love of it: when an idea lands, a working prototype is usually running within hours, built with the same AI agents and automations he sells. He puts his own output at roughly 20× what it was before agents, and the Agentic OS behind this site is the working proof, documented in public with the tools he actually ran and what they really cost.
AI & Automation Services
Want a pipeline like this running in your business?
I'm Qasim — I design and ship AI agents and n8n automations for solo operators and small teams. Tell me what's eating your team's week, and I'll scope a fix.
Related reading
Synthetic Data for AI Agent Evals: Build the Set Before You Have Users
Real production traces are the best eval data you can get, and most teams do not have enough of them yet. Here is the concrete mechanism for generating a synthetic eval set from a handful of real examples, plus the honest failure modes: data that drifts from what real users do,
How to Test and Evaluate n8n AI Agents: Accuracy, Mocks and Regression
An AI agent is non-deterministic, so 'it worked when I tried it' is not testing. Use n8n's built-in Evaluation feature, a golden test set, and the right scoring metrics to test n8n AI agents and prove a change made it better, not worse.
LLM-as-a-Judge Pitfalls: Flaky Scores, Self-Preference, Grading on a Curve
An LLM judge can pass 80%+ agreement with human raters and still lie to you in specific, documented ways: non-deterministic scores, self-preference bias, leniency, and overfitting to the judge itself. Here is what independently-verified research says about each pitfall, and the
Choosing an LLM for Production: The Decisions That Stick
Every model comparison you read was written against someone else's task. Twelve lessons on building the evaluation that produces your answer, pricing the choice properly, and making it reversible before the model changes underneath you.
RAG Evaluation: How to Measure If Your Retrieval Is Actually Good
Your RAG pipeline feels okay, but no number says if retrieval is good. This is the reproducible scorecard: context precision and recall for retrieval, faithfulness and answer relevancy for generation, scored 0 to 1 with Ragas, plus which metric to read when an answer is wrong.
Local LLMs for Business: When Running Your Own Is Worth It
Local is free is the sentence that starts most bad local-LLM projects. Eleven lessons on naming a real reason, the costs that never appear on an invoice, sizing hardware to the model, proving privacy properly, and knowing when to give it back.





