Both add a self-reflective quality check on retrieval and act on it: Self-RAG via reflection tokens, CRAG via a lightweight evaluator. Standard RAG just trusts whatever came back.
Imagine you ask a friend to look something up in a library. Standard RAG is a friend who grabs the first books off the shelf and reads from them no matter what. Self-RAG and CRAG are friends who pause and ask themselves: are these books actually about the question? If not, they go back, try a different shelf, or search online. Self-RAG was trained to spend extra effort emitting little check mark words as it works, like 'do I even need a book here?' and 'does the book actually answer this?' CRAG is simpler: it has a small helper that scores how relevant the books look, and if the score is low, it switches strategies. Both share one big idea: do not blindly trust the first results.
Concept explanation~2 min read
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Concept explanation~2 min read
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Self-RAG and Corrective RAG (CRAG) are the two canonical 'don't trust your retrieval blindly' methods in the 2023-2024 RAG literature. They share one core insight: standard retrieve then generate assumes the retrieval is good, and when it is not, the system silently hallucinates. Both methods add an explicit quality gate and a corrective action when quality is low.
The senior signal in this MCQ is being able to (1) identify the shared mechanism in option C, (2) distinguish the two methods cleanly without conflating them, and (3) explain why options A, B, and D are wrong with reasons more interesting than 'it does not match the paper.' This deep dive walks each method, contrasts them with the distractors, and closes with how the 2026 production landscape reproduces the same patterns via tool-use loops on frontier models.
The shared insight: retrieval is not ground truth
Standard RAG runs the retriever once, takes the top-k chunks, and passes them to the generator. The implicit assumption is that the retrieved chunks are relevant. In practice, retrieval misses for many reasons.
Out of distribution queries. The user asks about something the corpus does not cover. The retriever returns the topically nearest chunks, which are still wrong. The generator dutifully writes an answer from irrelevant chunks.
Rare-entity queries. The query mentions a specific person, product, or case that the corpus indexes thinly. The retrieved chunks are about generally similar entities but not the specific one. The generator confuses them.
Phrased-incorrectly queries. The user's vocabulary does not match the corpus's vocabulary. Hybrid retrieval helps, but does not solve, this. The retriever returns chunks that match the surface form but not the intent.
Stale-index queries. The corpus has not been updated; the question is about something newer. The retriever returns the closest available, which is wrong.
In all four cases, standard RAG produces a confident hallucination because the generator was not told retrieval was bad. Self-RAG and CRAG both add an explicit quality check and a corrective action. That is the shared mechanism described in option C.
Situations where this technique stops working.
2–4 min · Everything important, quickly.
# CRAG-style corrective gate.
from enum import Enum
class Grade(Enum):
CORRECT = "correct"
AMBIGUOUS = "ambiguous"
INCORRECT = "incorrect"
async def crag_answer(query: str) -> str:
chunks = await retrieve(query, top_k=8)
grade = await evaluator.grade(query, chunks) # T5-style classifier
if grade == Grade.CORRECT:
context = await knowledge_refinement(chunks) # strip level filter
elif grade == Grade.INCORRECT:
rewritten = await rewrite_query(query)
context = await web_search(rewritten)
else: # AMBIGUOUS
web = await web_search(query)
context = await knowledge_refinement(chunks) + web
return await generator.complete(query, context)| Aspect | Standard RAG | Self-RAG | CRAG |
|---|---|---|---|
| Quality gate | none | reflection tokens in generator | external evaluator model |
| Decides when to retrieve | always retrieves | [Retrieve] token per segment | always retrieves, then grades |
| Corrective action | none | self-critique, skip, refuse | web search, query rewrite |
| Generator requirement | any frozen LLM | fine-tuned on reflection data | any frozen LLM |
| Extra inference cost | 1x | 1.2-1.5x (reflection tokens) | 1.1-1.3x (one evaluator call) |
| 2026 adoption | default everywhere | via tool-use on frontier models | common in LangChain / LlamaIndex |
Real products, models, and research that use this idea.
- Self-RAG paper by Asai et al. ships a 7B and 13B fine-tuned LLaMA-2 model that emits the four reflection tokens during decoding.
- CRAG paper by Yan et al. uses a T5-large evaluator and falls back to Google Search via the Serper API for the corrective web step.
What an interviewer would ask next. Try answering before peeking at the approach.
QHow would you implement Self-RAG-style gating on top of a closed weight frontier model like Claude Opus 4.7 or GPT-5.5?
Use a tool-use loop. Expose a retrieve_documents tool; the model decides when to call it. Add a self-critique prompt that asks the model to score each retrieved chunk's relevance and the final answer's faithfulness, mirroring Self-RAG's reflection tokens in natural language.
Red flags & common mistakes
The phrases that signal junior thinking. Click to expand.
Red flags & common mistakes
The phrases that signal junior thinking. Click to expand.
Conflating these with multi-query retrieval. Multi-query expands the question into paraphrases and runs them in parallel; Self-RAG and CRAG inspect the results and react to quality.
60 second bullets to scan on the way to the call.
Why standard RAG's retrieve and pray assumption fails in practice
The four reflection tokens in Self-RAG and what each gates
Primary sources. Browse if you want the original framing.
- Asai et al., Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection
- Yan et al., Corrective Retrieval Augmented Generation (CRAG)
- Jeong et al., Adaptive-RAG: Learning to Adapt Retrieval-Augmented LLMs through Question Complexity
- Lewis et al., Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks
Same topic, related formats. Practice these next.