Reference-Guided Verdict: LLM s-as-Judges in Automatic Evaluation of Free-Form QA (2025)

Abstract: The emergence of Large Language Models (LLMs) as chat assistants capable of generating human-like conversations has amplified the need for robust evaluation methods, particularly for open-ended tasks. Conventional metrics such as EM and F1, while useful, are inadequate for capturing the full semantics and contextual depth of such generative outputs. We propose a reference-guided verdict method that automates the evaluation process by leveraging multiple LLMs as judges. Through experiments on free-form question-answering tasks, we demonstrate that combining multiple models improves the reliability and accuracy of evaluations, especially in tasks where a single model may struggle. The results indicate a strong correlation with human evaluations, establishing the proposed method as a reliable alternative to traditional metrics.

## introduction a central challenge in evaluating free-form question answering (qa) lies in the inherent diversity of responses. unlike tasks with deterministic outputs, free-form qa answers may differ in lexical choice and structure. conventional automatic metrics such as exact match (em) are insufficient for this setting @xcite , as they emphasize surface-form similarity and fail to account for legitimate lexical and compositional variation, often penalizing semantically correct answers that differ in phrasing @xcite . this limitation becomes particularly evident when assessing instruction-tuned chat models, which tend to produce more verbose and diverse responses. to address these challenges, researchers and practitioners often rely on human evaluations. it is more valuable in assessing aspects that automated metrics often miss @xcite . while human evaluation is still considered the "gold standard" for evaluating the quality of generated text, it has several limitations. it is financially demanding, time-consuming @xcite , and often lacks scalability @xcite . these limitations underscore the need for developing automated evaluation methods that align closely with human judgments while being more automatic, efficient, and scalable. recently, a paradigm shift has emerged to evaluate candidate model outputs by utilizing llms as judges @xcite . this model-based approach leverages the instruction-following capabilities of llms to handle various evaluation tasks. while this has proven effective for subjective tasks such as summarization and dialogue @xcite , where judgments can be made in a reference-free manner, its application to free-form qa remains largely underexplored @xcite . in contrast to subjective evaluation, objective evaluation of factual correctness typically requires reference answers, as correctness cannot be reliably determined solely through model instructions @xcite . some studies have considered the reference-guided method @xcite ; however, the objective is to guide judges in pairwise comparison and single-answer scoring. in this study, we utilize llms to evaluate freeform qa tasks through a reference-guided verdict method. the method incorporates the input to the candidate, the candidate model response, and the reference answer to guide an llm judge during evaluation. motivated by human evaluation practices, where multiple annotators assess each output, our approach considers multiple llms as judges. the proposed method combines verdicts via majority voting to ensure a reliable evaluation of freeform qa. our findings indicate that llm-based evaluations achieve substantial to perfect agreement with human judgments, as measured by standard inter-rater agreement metrics (e.g., cohen's kappa). task complexity emerges as a key factor figure 1: overview of our methodology. initially, we prompt candidate llm with a question (x) from the truthfulqa dataset. the candidate llm generates a free-form output (a). this is then given to each llm-asa-judge along with x and reference answer r (i.e., x, a, r) and instructed (i.e., true or false with explanation) to evaluate the candidate llm output. the llm judges deliver their verdicts and provide explanations for their decisions. ## methodology inspired by the way human evaluations typically involve multiple annotators to ensure reliability, we propose a method that leverages multiple llms as judges for evaluating free-form qa outputs. in this setup, a candidate model receives a question and generates an answer. the evaluation then involves three components: the original question, a reference answer, and the candidate's output. these are provided to a judge model, an llm tasked with evaluating whether the candidate's answer correctly responds to the question and aligns with the reference answer. the final evaluation verdict is then determined by aggregating the individual judgments via majority voting, which improves robustness and reduces variance compared to relying on a single model. figure 1 provides an overview of our method. ## experiments we utilize the following settings to examine the performance and reliability of llms-as-judges in reference-guided evaluations. ## results as depicted in ## related work to address the limitations of traditional n-grambased metrics like bleu and rouge, various model-based methods, such as bertscore @xcite , aim to provide semantically informed evaluation. however, embedding-based methods still struggle with open-ended generation @xcite . recent advances in llms have enabled automatic, context-aware evaluation (chiang and lee, 2023), applied in settings such as pairwise, single-answer, and reference-guided evaluations @xcite @xcite . despite some promising results, the llm-asa-judge approach suffers from inherent llm biases @xcite , including positional bias @xcite @xcite , verbosity bias @xcite , and self-enhancement bias @xcite , where the model may favor certain response positions, longer answers, or their own outputs. llms often conflate different evaluation criteria @xcite , which significantly undermines the reliability of evaluations @xcite . more closely related to our study are recent efforts in open-domain qa evaluation. wang et al. @xcite introduced the evouna benchmark, showing that while llm evaluators move beyond exact match, they still frequently misjudge paraphrased or lengthy answers compared to humans. similarly, kamalloo et al. @xcite explored llm-based evaluators for qa and found that automatic methods can misrank systems and are sensitive to hallucinations. both works highlight the shortcomings of individual llm evaluators in qa, reinforcing the need for more reliable and robust evaluation strategies. extending this line of work, the dafe framework (badshah and sajjad, 2025) and its recent extension (clev) propose lightweight ensemble methods that selectively engage multiple llm judges, improving alignment with human judgments while reducing computational cost. in contrast, ur study prioritizes robustness by leveraging task-specific reference answers and full majority voting across multiple judges. building on these insights, our study introduces a multi-llm evaluation approach, inspired by human annotation practices where multiple annotators and majority voting improve reliability. by leveraging task-specific reference answers, we guide llm judges toward more impartial decisions and reduce the effect of individual biases. ## conclusion this study presents a reference-guided verdict method for evaluating free-form qa using llms as judges. by incorporating multiple llms and aggregating their decisions via majority voting, our approach achieves high alignment with human evaluation while addressing the limitations of traditional automatic metrics. the results demonstrate that reference guidance enhances objectivity and that multi-model judgment mitigates individual model biases, offering a scalable and reliable alternative for evaluating open-ended qa tasks.