🤖 AI

Generating Leakage-Free Benchmarks for Robust RAG Evaluation

This paper introduces SeedRG, a semi-synthetic benchmark generation pipeline that mitigates knowledge leakage and benchmark aging in Retrieval-Augmented Generation (RAG) evaluation by extracting reasoning graphs from seed data and generating novel, structurally similar examples that cannot be answered from an LLM's parametric memory.

Original authors: Jiayi Liu, Jiaxing Zhang, Bowen Jin, Jennifer Neville

Published 2026-05-12

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jiayi Liu, Jiaxing Zhang, Bowen Jin, Jennifer Neville

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a teacher trying to grade a student's ability to use a library. You give them a question and a stack of books, and you want to see if they can find the answer in the books.

But here's the problem: The student has already memorized the answers to most of these questions from reading the books years ago. When you ask, "Who wrote Pride and Prejudice?", they don't need to look in the stack of books you gave them; they just remember it.

This is exactly what the paper "Generating Leakage-Free Benchmarks for Robust RAG Evaluation" is about. It argues that we are currently testing AI systems (specifically those that use a "library" of external data, called RAG) with questions that are too easy because the AI already knows the answers from its own internal memory.

Here is a breakdown of the paper's story, using simple analogies:

1. The Problem: The "Cheating" Test

The authors found that popular tests used to judge AI are "leaking" information.

The Analogy: Imagine giving a student a math test where the answers are written on the back of their hand. Even if you tell them, "You must use your calculator to solve this," they just look at their hand. You can't tell if their calculator is good or bad because they aren't actually using it.
The Reality: In the world of AI, the "hand" is the AI's internal memory (parametric knowledge). The "calculator" is the retrieval system (RAG). Because the AI already knows the facts in the test questions, the retrieval system is redundant. This makes it impossible to tell which AI system is actually better at finding information.
The "Aging" Issue: The paper notes that this gets worse over time. As AI models are retrained on old test questions, they "memorize" the tests. The tests become useless, like a security guard who has memorized the thief's face but keeps letting them in because they know the thief's name.

2. The Solution: SeedRG (The "Mad Libs" Machine)

To fix this, the authors created a new tool called SeedRG. Instead of just asking an AI to "make up new questions" (which often leads to the AI accidentally using facts it already knows), SeedRG uses a clever, structured approach.

The Analogy: Think of a "Mad Libs" game. You have a story with blanks for nouns, verbs, and places.
- Old Way: Just write a new story from scratch. (The AI might accidentally write about "New York" or "Einstein" because it knows those words well).
- SeedRG Way: Take an existing story. Identify the "slots" (e.g., a specific city, a specific scientist). Then, swap those slots with brand new, obscure names that the AI has never heard of (e.g., swapping "New York" for "Zog-42" and "Einstein" for "Dr. Glorp").
How it works:
1. Map the Logic: It draws a map (a "reasoning graph") of how the original question connects facts.
2. Swap the Parts: It replaces the specific names with new ones, but keeps the logic map exactly the same.
3. Double-Check: It runs a test to make sure the AI cannot answer the new question without the provided text. If the AI guesses the answer, the question is thrown out and regenerated.

3. The Results: Finally Seeing the Difference

When the authors tested their new "SeedRG" benchmarks against the old ones, the results were dramatic.

The Old Tests: All the different AI systems looked the same. They all got high scores because they were just reciting what they knew. It was like a race where everyone is standing still, but the finish line is moved to where they are standing.
The SeedRG Tests: Because the questions used new, unknown facts, the AI had to use the retrieval system (the "library"). Suddenly, the differences appeared. Some systems were great at finding the right book; others were terrible.
- The Metaphor: It's like finally giving the students a test on a subject they haven't studied yet. Now you can actually see who is good at looking up information and who is just guessing.

4. Why the "Map" Matters

The paper also discovered something interesting about how hard a question is.

The Discovery: The difficulty of a question isn't just about the words; it's about the structure of the connections between facts (the "reasoning graph").
The Analogy: If you have a map with 3 stops, it's easy. If you have a map with 10 stops, it's hard. SeedRG ensures that when it swaps the names, it keeps the shape of the map exactly the same. This proves that the difficulty comes from the path you have to take, not the names on the signs.

Summary

The paper says: "Current tests are broken because AI systems are cheating by using their own memory. We built a new tool, SeedRG, that creates fresh, impossible-to-memorize questions by swapping out names while keeping the logic the same. This forces the AI to actually use its search tools, allowing us to finally see which systems are truly good at finding information."

Technical Summary: Generating Leakage-Free Benchmarks for Robust RAG Evaluation

Problem Statement

The paper identifies a critical flaw in current Retrieval-Augmented Generation (RAG) evaluation: knowledge leakage. Many existing multi-hop question answering (QA) benchmarks contain questions that Large Language Models (LLMs) can answer correctly using only their parametric memory, without needing to retrieve external documents.

This phenomenon leads to unreliable evaluations where performance is dominated by the model's internal knowledge rather than the quality of the retrieval system. Consequently, current benchmarks fail to distinguish between different RAG architectures (e.g., HippoRAG, GraphRAG, SemanticRAG), as even weak retrievers inherit high performance from the underlying model.

The problem is exacerbated by benchmark aging. As benchmarks are reused in training pipelines and data curation, their content is increasingly absorbed into model parameters, further increasing the rate of leakage and rendering static benchmarks ineffective over time.

Methodology: SeedRG

To address these issues, the authors propose SeedRG, a semi-synthetic benchmark generation pipeline designed to create leakage-free, difficulty-preserving benchmarks. The framework operates on a seed dataset and transforms it into new instances through the following steps:

Reasoning Graph Extraction: For each question-context pair in the seed dataset, SeedRG extracts a reasoning graph to capture the underlying reasoning structure (hops, dependency chains, and entity connectivity).
Type-Constrained Entity Replacement: The system generates new examples by replacing entities in the question, context, and answer with novel counterparts of the same semantic type (e.g., replacing one composer with another). These new entities are selected to be unlikely to exist in the model's parametric knowledge.
- The replacement is applied to the question ( $q'$ ), answer ( $a'$ ), and context ( $c'$ ).
- Context generation can occur via direct text substitution or by regenerating natural language from transformed knowledge graph triplets.
Dual Verification: To ensure quality, the pipeline enforces two checks:
- Knowledge Leakage Filter: The generated question is queried against the LLM without context. If the model answers correctly, the instance is rejected as "leaking."
- Reasoning Graph Consistency Check: The reasoning graph of the new instance is compared to the original. Structural equivalence ( $G' \cong G$ ) is verified to ensure the reasoning difficulty remains preserved.

This process allows for renewable generation, where new benchmark instances can be produced on demand to counteract benchmark aging.

Key Contributions

The paper outlines three primary contributions:

Systematic Evidence of Leakage: The authors provide empirical evidence that three widely used multi-hop QA benchmarks (HotpotQA, 2WikiMultiHopQA, QASC) suffer from significant knowledge leakage, with models answering 31% to 78% of questions without retrieval. They formalize benchmark quality using two metrics: Leakage Error (accuracy without context) and Answerability Accuracy (the performance gain provided by correct context).
The SeedRG Pipeline: A novel framework that combines reasoning graph extraction with type-constrained entity replacement and dual verification to generate benchmarks that are retrieval-dependent and difficulty-preserving.
Discriminative Evaluation: Demonstration that SeedRG reveals meaningful performance differences across RAG systems that are obscured in existing benchmarks, while showing that naive direct generation (DG) fails to adequately control for leakage and factual consistency.

Experimental Results

The authors evaluated SeedRG using three seed benchmarks (HotpotQA, 2WikiMultiHopQA, QASC) and three frontier LLMs (GPT-5, Claude Sonnet 4.5, Gemini 2.5 Flash).

Reduction in Leakage: SeedRG reduced knowledge leakage by at least 78% compared to original benchmarks. For instance, on HotpotQA with GPT-5, leakage error dropped from 50% (original) to 1.4% (SeedRG). In contrast, Direct Generation (DG) only reduced leakage partially (to 18–53%).
Factual Consistency: SeedRG achieved 0% factual inconsistencies in generated contexts, whereas DG exhibited 53–70% inconsistency rates.
Structural Preservation: SeedRG maintained graph structure metrics (nodes, edges, density) within a 5% deviation of the original, while DG deviated by up to 38%.
RAG System Differentiation: On original benchmarks, RAG systems clustered within a narrow accuracy range (e.g., within 3% on HotpotQA), making them indistinguishable. SeedRG widened this spread to 10–18%, revealing clear hierarchies (e.g., HippoRAG consistently outperforming OGRAG and GraphRAG).
Stability: Repeated generations of SeedRG benchmarks showed stable performance rankings across RAG systems, indicating robustness.

Significance and Claims

The paper claims that SeedRG enables a more discriminative and robust evaluation of RAG systems by removing the confounding effect of parametric knowledge. By ensuring that questions are unsolvable without retrieval, SeedRG isolates the retrieval component's contribution, allowing researchers to accurately measure how different retrieval strategies influence downstream reasoning.

Furthermore, the authors establish a link between reasoning difficulty and graph structure, demonstrating that structural variations induce predictable changes in model accuracy. This provides a principled basis for controlling task difficulty in benchmark generation. The work suggests that future evaluation should move beyond static datasets toward renewable, leakage-free generation to maintain the validity of RAG research as models continue to absorb training data.