Your LLM Judge Is Lying
About Your Agent's Quality

You deployed a support agent. You're scoring it with GPT-4. The scores look great. Your customers disagree. Here's why — backed by 15+ papers from 2024–2025.

March 2026 · Verixa Lab

When you use an LLM to judge your support agent's responses, you're getting a number that feels precise but is systematically distorted by at least six independent biases — each one invisible in your dashboard, each one compounding on the others. The research is clear: that 4.2/5 quality score your agent shows? It could be a 3.1 under honest evaluation.

Illustrative cascade based on documented bias magnitudes from Zheng et al. 2023, Shi et al. 2024, Wataoka et al. 2024

If you use GPT-4 to score your agent's GPT-4 outputs, you've built a system that literally reviews its own homework. Research confirms that models systematically rate their own outputs — and outputs from sibling models — higher than equally good alternatives. The cause is perplexity: LLMs prefer text that "sounds" like text they would write.

In pairwise evaluations — "is response A or B better?" — LLM judges consistently pick the one that appears first. This isn't a subtle effect. Simply swapping the order of two identical-quality responses can flip the verdict. For support agents, this means your A/B test results between prompt versions or model configs may reflect presentation order, not actual quality.

LLM judges reward verbosity. A support response that says "Your order has been refunded" scores lower than a five-paragraph essay that says the same thing with filler. Over time, your agent will optimize for what the judge rewards — producing bloated, over-explained responses that tank customer satisfaction even as judge scores climb.

In support, accuracy isn't generic — it's domain-specific. A billing answer that's 95% right but gets the refund policy wrong is a catastrophic failure. LLM judges can't tell the difference. Across specialized fields, judges agree with human experts barely more than a coin flip.

This is the most dangerous failure mode for support agents. LLM judges evaluate surface quality — fluency, structure, tone — not factual correctness. A support response that confidently gives the wrong refund policy, cites a nonexistent help article, or hallucinates a product feature will score well because it sounds right.

In clinical settings, LLMs repeat or elaborate on planted false information in up to 83% of cases. In legal evaluation, LLM judges accepted responses that cited nonexistent legal provisions. If your support agent hallucinates a return policy, the judge will rate it 4/5 for helpfulness.

If you optimize your agent against an LLM judge (via RLHF, prompt tuning, or any feedback loop), the agent will eventually learn to exploit the judge's weaknesses — not improve actual quality. Formatting tricks, confident tone, verbose padding, and keyword stuffing all reliably increase judge scores without improving the customer experience.

LLM judge scores are fragile. The same response, evaluated with the same model, can receive wildly different scores based on minor prompt variations — rubric order, numbering format, or how you phrase "quality." This makes week-over-week comparisons meaningless and A/B tests unreliable.

LLM judges are non-deterministic — run the same evaluation three times, get three different scores. Multiply this by multilingual support queues and you get evaluation noise so high it drowns out real signal. For low-resource languages, judge consistency drops to Fleiss' κ ≈ 0.3 — barely above random chance.