Human-Review Routing Decision Prompt Template

This prompt is designed for a specific moment in your verification pipeline: the decision gate between automated processing and human judgment. It assumes you have already extracted discrete claims from source content, scored each claim for evidence sufficiency, and assembled an evidence summary. The prompt's job is not to perform any of that upstream work—it is to consume those outputs and produce a consistent, auditable routing decision. Use it when your pipeline has reached the point where a claim's confidence score and supporting evidence are known, and you need a deterministic, explainable rule for whether to auto-verify or escalate.

The ideal user is a verification pipeline operator or an engineer integrating this prompt into an automated workflow. The required inputs are a single claim statement, a confidence score (typically a float between 0.0 and 1.0), and a structured evidence summary that includes source identifiers and a brief assessment of support or contradiction. The prompt is not suitable for initial claim extraction, evidence retrieval, or the scoring step itself. It also should not be used as a general-purpose content moderation tool or for routing tasks outside the fact-checking domain. If your pipeline lacks calibrated confidence scores or structured evidence, you must implement those upstream components first.

Before wiring this prompt into production, define your routing thresholds explicitly. A common pattern is to auto-verify claims above 0.85 confidence, escalate those between 0.5 and 0.85, and reject or flag claims below 0.5 for further investigation. These thresholds should be configurable, not hard-coded into the prompt, so you can adjust them based on operational cost, latency tolerance, and accuracy requirements. The prompt's output is a structured routing decision, not a final verification result. Always log the decision, the inputs, and the model's reasoning for auditability. If the claim involves regulated domains such as healthcare or finance, the escalation path should be mandatory regardless of confidence score, and a human reviewer must always be in the loop.

This prompt template is the core decision engine for your verification triage pipeline. It takes a single claim, its confidence score, the available evidence, and your operational thresholds, then produces a structured routing decision. The output includes a clear route_to_human boolean, a severity classification, and—when escalation is required—a pre-assembled review packet containing the claim, evidence summary, contradiction flags, and specific questions for the reviewer. Paste this into your orchestration layer and replace the bracketed variables with live data from your upstream scoring and evidence retrieval systems.

textCopy
SYSTEM:
You are a verification triage router in a production fact-checking pipeline. Your job is to decide whether a claim can be auto-verified based on available evidence and confidence thresholds, or whether it must be escalated for human review. You do not re-score the claim. You apply the provided thresholds, assess evidence completeness, and package context for reviewers when escalation is required. Never fabricate evidence or confidence values. If the input is missing required fields, flag it as malformed and request resubmission.

ROUTING RULES:
- If [CONFIDENCE_SCORE] >= [AUTO_VERIFY_THRESHOLD] AND [EVIDENCE_SUFFICIENCY_SCORE] >= [AUTO_SUFFICIENCY_THRESHOLD] AND [CONTRADICTION_COUNT] == 0, route to auto-verify.
- If [CONFIDENCE_SCORE] < [HUMAN_REVIEW_THRESHOLD] OR [EVIDENCE_SUFFICIENCY_SCORE] < [HUMAN_SUFFICIENCY_THRESHOLD] OR [CONTRADICTION_COUNT] > 0, route to human review.
- If [CONFIDENCE_SCORE] is between thresholds, evaluate [CLAIM_IMPACT_LEVEL] and [VERIFICATION_COST] to decide.
- If [HALLUCINATION_RISK_FLAG] is true, always escalate regardless of score.

OUTPUT_SCHEMA:
{
  "route_to_human": boolean,
  "routing_decision": "auto_verify" | "human_review" | "malformed_input",
  "severity": "routine" | "priority" | "critical",
  "reasoning": "string explaining the decision with reference to thresholds and evidence state",
  "review_packet": {
    "claim_text": "string",
    "claim_id": "string",
    "confidence_score": number,
    "evidence_summary": "string summarizing supporting and contradicting evidence",
    "contradiction_details": [
      {
        "source": "string",
        "contradicting_statement": "string",
        "severity": "direct_contradiction" | "partial_conflict" | "temporal_inconsistency"
      }
    ],
    "missing_evidence_gaps": ["string"],
    "specific_review_questions": ["string"],
    "source_authority_notes": "string",
    "hallucination_risk_flag": boolean
  } | null
}

CONSTRAINTS:
- The review_packet must be null when route_to_human is false.
- specific_review_questions must be actionable questions a human reviewer can answer, not restatements of the claim.
- evidence_summary must cite specific sources from [EVIDENCE_LIST], not generic descriptions.
- If the input is malformed, set routing_decision to "malformed_input" and leave review_packet null.

USER:
Route the following claim through the verification triage pipeline.

CLAIM: [CLAIM_TEXT]
CLAIM_ID: [CLAIM_ID]
CONFIDENCE_SCORE: [CONFIDENCE_SCORE]
EVIDENCE_SUFFICIENCY_SCORE: [EVIDENCE_SUFFICIENCY_SCORE]
CONTRADICTION_COUNT: [CONTRADICTION_COUNT]
HALLUCINATION_RISK_FLAG: [HALLUCINATION_RISK_FLAG]
CLAIM_IMPACT_LEVEL: [CLAIM_IMPACT_LEVEL]
VERIFICATION_COST: [VERIFICATION_COST]
EVIDENCE_LIST: [EVIDENCE_LIST]
CONTRADICTION_DETAILS: [CONTRADICTION_DETAILS]
MISSING_EVIDENCE_GAPS: [MISSING_EVIDENCE_GAPS]
SOURCE_AUTHORITY_NOTES: [SOURCE_AUTHORITY_NOTES]

THRESHOLDS:
AUTO_VERIFY_THRESHOLD: [AUTO_VERIFY_THRESHOLD]
AUTO_SUFFICIENCY_THRESHOLD: [AUTO_SUFFICIENCY_THRESHOLD]
HUMAN_REVIEW_THRESHOLD: [HUMAN_REVIEW_THRESHOLD]
HUMAN_SUFFICIENCY_THRESHOLD: [HUMAN_SUFFICIENCY_THRESHOLD]

To adapt this template, start by wiring your upstream scoring outputs directly into the placeholders. The [EVIDENCE_LIST] should be a serialized JSON array of evidence objects, each containing a source identifier, a snippet, and a relevance score. The [CONTRADICTION_DETAILS] placeholder expects the same structure as the output schema's contradiction_details array—pre-populate it from your contradiction detection step. The thresholds should be pulled from your operational configuration, not hardcoded, so you can adjust routing sensitivity without changing the prompt. If your pipeline uses multiple models for confidence scoring, aggregate scores before this prompt; do not ask the router to perform model arbitration. For high-stakes domains like healthcare or legal claims, set [HUMAN_REVIEW_THRESHOLD] higher than your default and add a [REQUIRED_REVIEWER_ROLE] field to the review packet so your downstream dispatch system routes to the right specialist.

This prompt is designed to sit at the decision boundary between automated verification and human review. It should be called after claim extraction, evidence matching, and confidence scoring have already completed. The prompt expects a structured input payload containing the claim, its confidence score, the evidence inventory, and any contradiction flags. The output is a routing decision (auto-verify, escalate, or reject) plus a packaged review context for human reviewers. Do not call this prompt on claims that haven't been scored—it will hallucinate confidence signals rather than flagging missing data.

Wire this prompt into your pipeline as a post-scoring step. The application layer should validate the input payload before calling the model: check that confidence_score is a float between 0 and 1, that evidence_items is a non-empty array with each item containing source_id, relevance_score, and authority_tier, and that contradiction_flags is present even if empty. After receiving the model response, validate the output schema: routing_decision must be one of auto_verify, escalate, or reject; review_packet must contain summary, evidence_brief, and specific_questions; and escalation_reason must be non-null when the decision is escalate. If validation fails, retry once with the validation errors appended to the prompt as [PREVIOUS_ERRORS]. If the second attempt also fails, default to escalate and log the failure for operator review. For high-stakes domains (healthcare, legal, finance), always require a human to confirm auto_verify decisions below a confidence threshold of 0.85, regardless of the model's routing output.

Model choice matters here. Use a model with strong instruction-following and structured output capabilities (GPT-4o, Claude 3.5 Sonnet, or equivalent). Avoid smaller models for this task—the routing logic requires weighing multiple evidence dimensions against domain-specific risk tolerances, and smaller models tend to over-escalate or under-escalate inconsistently. Set temperature=0 for deterministic routing decisions. Log every routing decision with the full input payload, model response, validation result, and final action taken. This audit trail is essential for tuning escalation thresholds over time and for compliance reviews. If you're processing claims in batch, implement a rate limiter and a dead-letter queue for claims that fail validation after retries—never silently drop a claim that couldn't be routed.