Chain of Verification: A Prompt That Catches Its Own Hallucinations (2026)
Chain of Verification (CoVe) is a four-step prompt that cuts hallucinations by making a model draft, plan verification questions, answer them independently, and rewrite keeping only what survived.

On this page
Quick answer (2026): Chain of Verification (CoVe) is a four-step prompt that cuts hallucinations by making a model fact-check its own draft. It (1) writes a draft answer, (2) plans short verification questions about the claims in that draft, (3) answers those questions independently in a fresh context so the answers are not anchored to the draft, and (4) rewrites the answer keeping only the claims that survived. Step 3 independence is the whole trick. It comes from Dhuliawala et al. at Meta AI, 2023.
The claim
A model that grades its own work in one breath will rubber-stamp its own mistakes. CoVe fixes that by splitting the work: draft first, then interrogate the draft with the draft out of sight. When the model answers a verification question without staring at its own confident prose, it stops agreeing with itself and starts catching itself.
This is the same instinct behind a 5-line eval that catches most hallucinations after the fact. CoVe moves that check earlier, into the same call, so a bad claim never leaves the building. It also pairs cleanly with plain chain of thought: CoT helps the model reason toward an answer, CoVe stops it from reasoning itself into a fiction.
The receipt: the 4-stage prompt
Copy this. It runs as one guided prompt and works on any capable model.
You will answer in four labeled stages. Do not skip a stage.
STAGE 1 - DRAFT
Answer the question below in 3 to 6 sentences.
Question: {your question}
STAGE 2 - PLAN CHECKS
List every discrete factual claim in your draft. For each claim, write
one short verification question whose answer could prove the claim wrong.
Number the questions. Include at least one existence check per named
entity, for example "Did this person ever hold that role at all?"
STAGE 3 - ANSWER CHECKS
Answer each verification question on its own. Use only what you actually
know. Do not reread the draft while answering. Label each answer
CONFIRMED, WRONG, or UNSURE.
STAGE 4 - REVISE
Rewrite the answer using only CONFIRMED claims. Delete WRONG claims.
Soften UNSURE claims to hedged language or cut them. Add no new claims.
Why the labeled stages: the paper's whole finding is that the verification answers must not be biased by the draft. Forcing separate, numbered questions and a rewrite that can only subtract is what buys the hallucination drop across Wikidata lists, closed-book QA, and longform biographies in the CoVe paper (Dhuliawala et al., 2023).
The receipt: the factored variant (stronger, pricier)
The single-prompt version still lets STAGE 3 peek at the draft, because it all lives in one context window. The factored variant enforces real independence with separate calls.
- Call A: run STAGE 1 and STAGE 2 only. Return the draft and the numbered verification questions.
- Call B: start a fresh context. Paste only the questions, none of the draft. Prompt: "Answer each question using only what you know. Label CONFIRMED, WRONG, or UNSURE." The model cannot agree with prose it never saw.
- Call C: paste the draft plus Call B's labeled answers. Run STAGE 4.
This is the configuration that scored best in the paper because the verification answers are genuinely uncontaminated. It roughly doubles token cost. Use it when the answer ships to a user and a wrong fact is expensive.
Which model, and where it holds up
CoVe is model-agnostic prompt structure, not a model feature. Claude follows the multi-stage labeling reliably and tends to be honest in STAGE 3 about what it does not know, per Anthropic's prompt guidance. GPT
runs it well too and is happy to emit strict CONFIRMED / WRONG / UNSURE labels you can parse, per OpenAI's prompting guide. On small or heavily quantized models, STAGE 3 gets lazy and just re-confirms everything. If that happens, force the factored variant so the checker never sees the draft.
The cheap collapse (when you cannot afford three calls)
For cost-sensitive, low-stakes runs, keep it to one call but tighten STAGE 3:
STAGE 3 - ANSWER CHECKS
Answer each verification question as if you had never seen your draft and
had to look it up cold. Contradict the draft freely. Label CONFIRMED,
WRONG, or UNSURE.
It is weaker than true factoring because the draft is still in context, but the "as if you never saw it" framing recovers a chunk of the benefit for roughly the price of one longer completion.
The failure mode
CoVe cannot catch a hallucination when the verification question inherits the draft's false premise. If the draft says "Ada was CEO in 2019" and STAGE 2 asks "When did Ada become CEO?", the check quietly assumes Ada was CEO at all and confirms a date for a job she never held. The fix is baked into the prompt above: demand one existence check per entity ("Was Ada ever CEO of this company?") before any detail question. Premise-checking questions catch the fabrications that detail-checking questions launder.
Second failure mode: STAGE 4 sneaking in new claims to make the rewrite read smoothly. The "add no new claims" line is not decoration. Without it the model re-hallucinates during the cleanup.
Ship it
- Start with the single 4-stage prompt for anything internal or low-stakes.
- Switch to the factored three-call variant the moment a wrong fact reaches a user.
- Always keep the existence-check line and the "add no new claims" line. Those two sentences do most of the work.
CoVe will not make a model omniscient. It makes a model stop agreeing with itself, which is where most confident-but-wrong answers come from.
Cost to test: about $0.02 for a short answer on a mid-tier model in the single-prompt form; the factored variant roughly doubles it.
Written by
Sam Q.Sam Q. writes terse, tested prompt recipes for PromptAttic. Claim, receipt, why, failure mode, ship.
FAQ
What is chain-of-verification (CoVe) prompting?
CoVe is a four-step prompt that reduces hallucinations. The model writes a draft answer, plans short verification questions about the claims in that draft, answers those questions independently so they are not anchored to the draft, then rewrites the answer keeping only the claims that survived. It was introduced by Dhuliawala et al. at Meta AI in 2023.
How is CoVe different from just asking the model to double-check its answer?
A plain double-check happens in one breath, with the draft in full view, so the model tends to rubber-stamp its own mistakes. CoVe separates the steps: it turns each claim into a discrete verification question and answers those questions without rereading the draft. That separation is what actually surfaces wrong claims instead of confirming them.
Why answer the verification questions in a separate call?
Independence is the core of the technique. In a single context window the model can still peek at its draft and agree with it. Running the answers in a fresh call, with only the questions pasted in and none of the draft, means the checker is judging the claims cold. That factored setup is the configuration that scored best in the original 2023 paper, at roughly double the token cost.
Does CoVe work on both GPT and Claude?
Yes. CoVe is prompt structure, not a model feature, so it runs on any capable model. Claude and GPT both follow the labeled stages and emit parseable CONFIRMED, WRONG, or UNSURE labels. On small or heavily quantized models the checking step gets lazy and re-confirms everything, in which case you should force the factored variant so the checker never sees the draft.
What hallucinations does CoVe still miss?
CoVe cannot catch a fabrication when the verification question inherits the same false premise. If the draft assumes someone held a role they never held, a question about when they took that role quietly confirms the premise. The fix is to demand at least one existence check per entity before any detail question, and to forbid the final rewrite from adding new claims.
How much does CoVe cost to run in 2026?
About two cents for a short answer on a mid-tier model in the single-prompt form. The factored three-call variant roughly doubles that. Reserve the factored version for answers that reach a user where a wrong fact is expensive, and use the single prompt for internal or low-stakes work.
Related recipes
A 5-line eval that catches 80% of hallucinations
Before you ship a generated answer, run one cheap second call that checks it against the source. Ask: is every claim in the answer supported by the provided context? Get back yes/no plus the first unsupported claim. Reject on no. Five lines of glue, catches the bulk of confident fabrications.
Chain of Thought Prompting: 6 Examples That Ship (2026)
Five paste-ready chain-of-thought prompting examples for 2026, each with its failure mode, plus when reasoning out loud makes the answer worse.
Multi-step JSON repair: make any model return valid JSON on the second try
Step one: ask for JSON. Step two: if JSON.parse throws, send the broken string plus the parser error back and ask only for a corrected version. Don't re-explain the task. Models fix syntax far more reliably than they self-correct semantics. Two steps, near-zero unparseable output.


