Human-in-the-Loop Fact Review Prompt

This playbook is for accuracy-critical product teams who need a structured human review step before AI-generated content is finalized. Use this prompt when automated hallucination detection has flagged claims that require human judgment, when the cost of a factual error is high (regulated industries, public-facing content, clinical or legal workflows), or when you need to build a feedback loop that improves automated detection thresholds over time. The prompt structures the review decision into confirm, correct, or escalate actions and captures reviewer rationale for audit trails and continuous improvement.

The ideal user is an engineering lead or AI architect integrating a human review queue into a production AI pipeline. Required context includes the original model output, the specific claims flagged by an automated detector, the source evidence for each claim, and the risk classification of the content. This prompt is not a general-purpose fact-checker, a replacement for automated hallucination detection, or a tool for real-time chat moderation. Do not use it when the cost of a factual error is negligible, when the review volume exceeds human capacity without a triage step, or when the flagged claims can be safely auto-corrected by a grounded regeneration prompt.

Before wiring this into your application, ensure you have a reliable upstream detection step that produces structured claim-evidence pairs. The prompt assumes each flagged claim is presented side-by-side with its source evidence, a confidence score from the detector, and a risk level. If your pipeline cannot produce this structured input, invest in a claim extraction and source verification prompt first. After implementing this review step, log every decision—confirm, correct, or escalate—along with the reviewer's rationale and timestamp. Use these logs to measure inter-reviewer agreement, identify detector weaknesses, and adjust automated thresholds so that only genuinely ambiguous claims reach the human queue.

This template structures a human review task for high-stakes fact-checking workflows. It presents a set of flagged claims alongside their source evidence, asks the reviewer to make a structured decision (confirm, correct, or escalate), and captures the reviewer's rationale. Use this when automated hallucination detection has flagged potential issues and a human must make the final call before the output reaches a user or system of record.

textCopy
You are a fact-review assistant preparing a structured review task for a human reviewer. Your job is to present the information clearly and neutrally. Do not make the decision yourself.

## Review Task

**Original Output:**
[ORIGINAL_OUTPUT]

**Source Context (provided to the model):**
[SOURCE_CONTEXT]

## Flagged Claims

For each claim below, the automated system flagged a potential factual issue. Review each claim against the source context.

[FLAGGED_CLAIMS]

## Reviewer Instructions

For each flagged claim, you must select one decision and provide your rationale:

- **CONFIRM:** The claim is accurate and fully supported by the source context.
- **CORRECT:** The claim is inaccurate. Provide the corrected statement and cite the specific source evidence.
- **ESCALATE:** The source context is insufficient to verify or correct this claim. Explain what evidence is missing.

## Output Format

Return a JSON object with the following structure:

{
  "review_id": "[REVIEW_ID]",
  "reviewer": "[REVIEWER_NAME]",
  "review_timestamp": "[TIMESTAMP]",
  "decisions": [
    {
      "claim_id": "string",
      "claim_text": "string",
      "decision": "CONFIRM | CORRECT | ESCALATE",
      "corrected_text": "string | null",
      "evidence_citation": "string | null",
      "rationale": "string"
    }
  ],
  "overall_notes": "string"
}

## Constraints

- Do not invent evidence. If the source context does not support a correction, escalate.
- Cite specific passages from the source context when confirming or correcting.
- If the original output contains multiple distinct factual errors in one claim, list them separately.
- Flag any claims that appear in the original output but have no corresponding source context at all.

Adaptation notes: Replace [FLAGGED_CLAIMS] with the structured output from your automated hallucination detection step. Each claim should include a unique claim_id, the claim text, and the detector's confidence score or reason for flagging. The [SOURCE_CONTEXT] placeholder should contain the exact context provided to the model that generated the original output—do not supplement it with additional sources, as the review must assess whether the model's output was faithful to what it was given. Wire the JSON output schema into your review queue system so that CORRECT and ESCALATE decisions trigger downstream workflows: corrections route back to regeneration, escalations route to subject-matter experts.

This prompt is designed to sit at a critical decision boundary in your AI pipeline: the point where a flagged claim and its evidence are presented to a human reviewer for a final decision. The implementation harness must treat this as a structured transaction with a clear lifecycle—submission, review, decision capture, and downstream action. The prompt itself is stateless, so your application layer must manage the review state, track which claims have been reviewed, and enforce that no output proceeds past this gate without a recorded human decision. Wire this prompt into a review queue system where each item includes the original model output, the extracted claims, the source evidence, and a unique review ID for traceability.

Build the harness with three core components: a submission handler, a decision recorder, and an escalation router. The submission handler formats the prompt with the required inputs—[ORIGINAL_OUTPUT], [EXTRACTED_CLAIMS], [SOURCE_EVIDENCE], and [REVIEWER_CONTEXT]—and presents it to the human reviewer through your UI or API. The decision recorder captures the structured output (confirm, correct, or escalate) along with the reviewer's rationale, timestamp, and identity, then writes this to an immutable audit log. The escalation router handles the 'escalate' path by forwarding the claim to a designated expert queue with full context preserved. Implement idempotency keys on submission to prevent duplicate reviews if the upstream pipeline retries.

For validation, parse the model's output against a strict schema before accepting it as a review decision. The expected fields are decision (enum: confirm, correct, escalate), corrected_text (required if correct), escalation_reason (required if escalate), and reviewer_rationale (always required). If the model produces malformed JSON or missing required fields, do not silently accept it—return a validation error to the reviewer with a clear message and re-prompt. Set a retry budget of at most 2 attempts for format errors before falling back to a simpler structured form. Log every validation failure for prompt improvement analysis.

Model choice matters here. Use a model with strong instruction-following and structured output capabilities, such as GPT-4o or Claude 3.5 Sonnet, because the prompt requires precise enum selection and conditional field population. Avoid smaller or older models that may conflate the decision types or omit the rationale. If you are operating in a regulated domain, ensure the model endpoint is deployed in your compliant environment and that no review data leaves your boundary. Consider setting temperature=0 to maximize decision consistency across reviewers and time.

Do not use this prompt as a substitute for actual human review in high-stakes workflows. The prompt structures the review interface, but the human decision is the authoritative step. Your harness should enforce that the reviewer_rationale field is non-empty and substantive before accepting the decision. Implement a timeout mechanism: if a review item sits in the queue beyond your SLA window, escalate it automatically with a 'review timed out' flag. Finally, feed confirmed and corrected decisions back into your evaluation pipeline to measure reviewer agreement rates and identify claims where the model's initial hallucination detection thresholds need tuning.