Multimodal Human-Review Handoff Packet Assembly Prompt

This prompt is designed for operations teams and verification pipeline engineers who need to consolidate the noisy, high-volume output of a cross-format verification system into a single, structured dossier for human review. The core job-to-be-done is transforming dozens or hundreds of individual machine verdicts—each with its own format-specific evidence snippet, confidence score, and metadata—into a prioritized, deduplicated, and reviewer-ready packet. The ideal user is someone managing a production verification pipeline where automated sub-prompts (e.g., text-to-table, image-to-text, audio-to-document) have already run and produced structured claim-evidence pairs, but a human must make the final call on high-stakes or low-confidence items before publication or action.

Use this prompt when your pipeline generates a high volume of claim verdicts across different formats and you need a single, coherent artifact that a human can review efficiently without being overwhelmed by raw machine output. The prompt assumes that upstream verification prompts have already produced structured claim-evidence pairs with machine verdicts and confidence scores. It does not perform the initial verification, extract claims from raw content, or retrieve evidence. Its value is in synthesis: it deduplicates similar claims, prioritizes by risk and uncertainty, groups related findings, and formats everything for a human reviewer's cognitive workflow. The output should include a prioritized claim list, format-typed evidence snippets, machine verdicts, uncertainty flags, and explicit reviewer guidance on what needs attention and why.

Do not use this prompt for single-format verification tasks, for generating the initial claim verdicts, or for fully automated publishing where no human review is required. It is also inappropriate when the upstream verification outputs are not yet structured—this prompt expects clean input, not raw model transcripts. If your pipeline includes claims that are already verified with high confidence and no ambiguity, consider filtering those out before assembly to keep the review packet focused. The prompt is not a replacement for a verification dashboard or a real-time monitoring system; it is a batch handoff artifact for periodic human review cycles. Before deploying, test the assembly prompt with representative multi-format claim sets to ensure it correctly prioritizes high-risk items and does not silently drop low-confidence but important findings.

This prompt template ingests a batch of cross-format verification results—claims matched against evidence from text, tables, images, audio, and video—and produces a single JSON handoff packet. It is designed for operations teams who need to move from machine-generated verdicts to human review without losing traceability. The prompt deduplicates overlapping findings, normalizes evidence snippets, prioritizes claims by risk, and generates actionable reviewer guidance. Use this when your verification pipeline has already produced per-claim outputs and you need a consolidated, review-ready artifact. Do not use this for raw claim extraction or initial evidence matching; those are upstream steps.

Below is the copy-ready prompt template. Replace each square-bracket placeholder with your pipeline's actual outputs before sending it to the model. The template assumes you have already run format-specific verification sub-prompts and collected their structured results. The model's job is assembly, deduplication, prioritization, and reviewer-guidance generation—not re-verification.

textCopy
You are an expert verification analyst assembling a human-review handoff packet from cross-format claim verification results.

## INPUT
You will receive a JSON array of verification results. Each result object contains:
- `claim_id`: string
- `claim_text`: string (the original claim)
- `claim_format`: string (text, table_cell, chart_data_point, image_ocr, audio_transcript_segment, video_segment)
- `evidence_snippets`: array of objects with `format`, `snippet_text`, `source_id`, `timestamp_or_cell_ref`
- `machine_verdict`: string (SUPPORTED | CONTRADICTED | UNVERIFIABLE | UNCERTAIN)
- `confidence_score`: number (0.0 to 1.0)
- `uncertainty_flags`: array of strings (e.g., ["OCR_ambiguity", "timestamp_mismatch", "unit_discrepancy"])
- `format_alignment_score`: number (0.0 to 1.0, how well cross-format evidence aligns)

[VERIFICATION_RESULTS]

## TASK
Assemble a structured human-review handoff packet from the provided verification results. Follow these steps in order:

1. **Deduplicate overlapping findings.** If multiple results refer to the same underlying claim with different format extractions, merge them into a single claim entry. Preserve all distinct evidence snippets and flag the merge in `deduplication_notes`.

2. **Prioritize claims by risk.** Assign each claim a `review_priority` of CRITICAL, HIGH, MEDIUM, or LOW based on:
   - CRITICAL: machine_verdict is CONTRADICTED with confidence > 0.7, or any claim with uncertainty_flags containing "OCR_ambiguity" or "timestamp_mismatch"
   - HIGH: machine_verdict is UNCERTAIN or UNVERIFIABLE with confidence < 0.5, or format_alignment_score < 0.4
   - MEDIUM: machine_verdict is SUPPORTED with confidence between 0.5 and 0.8
   - LOW: machine_verdict is SUPPORTED with confidence > 0.8 and no uncertainty_flags

3. **Normalize evidence snippets.** For each claim, produce a `normalized_evidence` array where each snippet includes:
   - `format`: original evidence format
   - `excerpt`: trimmed to 300 characters maximum, preserving key numbers and entity names
   - `source_ref`: compact source identifier
   - `relevance`: why this snippet matters for the claim (one sentence)

4. **Generate reviewer guidance.** For each claim, produce a `reviewer_guidance` object containing:
   - `action`: one of CONFIRM, INVESTIGATE, OVERRIDE, or DISMISS
   - `focus_areas`: array of specific things the reviewer should check
   - `suggested_questions`: array of 1-3 questions the reviewer should answer
   - `risk_note`: if priority is CRITICAL or HIGH, a one-sentence explanation of the risk

5. **Produce a summary section** with:
   - `total_claims_reviewed`: integer
   - `priority_counts`: object with counts per priority level
   - `format_distribution`: object with counts per claim_format
   - `unresolved_contradictions`: array of claim_ids where machine_verdict is CONTRADICTED
   - `recommended_review_order`: array of claim_ids in suggested review sequence

## OUTPUT SCHEMA
Return a single JSON object conforming to this structure:
{
  "handoff_packet": {
    "packet_id": "string",
    "generated_at": "ISO8601 timestamp",
    "summary": { ... },
    "claims": [
      {
        "claim_id": "string",
        "claim_text": "string",
        "claim_format": "string",
        "review_priority": "CRITICAL | HIGH | MEDIUM | LOW",
        "machine_verdict": "string",
        "confidence_score": number,
        "uncertainty_flags": ["string"],
        "format_alignment_score": number,
        "deduplication_notes": "string or null",
        "normalized_evidence": [
          {
            "format": "string",
            "excerpt": "string (max 300 chars)",
            "source_ref": "string",
            "relevance": "string"
          }
        ],
        "reviewer_guidance": {
          "action": "CONFIRM | INVESTIGATE | OVERRIDE | DISMISS",
          "focus_areas": ["string"],
          "suggested_questions": ["string"],
          "risk_note": "string or null"
        }
      }
    ]
  }
}

## CONSTRAINTS
- Do not re-verify claims. Use the provided machine_verdict and confidence_score as-is.
- Do not fabricate evidence snippets. Only use snippets from the input.
- If two claims are merged during deduplication, preserve both original claim_ids in deduplication_notes.
- Normalized evidence excerpts must not exceed 300 characters. Truncate with "..." if needed.
- The recommended_review_order must place CRITICAL claims first, then HIGH, then MEDIUM, then LOW.
- If no claims are provided, return a valid handoff_packet with empty claims array and summary reflecting zero claims.
- Output only the JSON object. No markdown fences, no commentary.

To adapt this template for your pipeline, replace [VERIFICATION_RESULTS] with your actual JSON array of per-claim verification outputs. If your upstream verification prompts use different field names, map them to the expected input schema before calling this prompt. For high-stakes domains like healthcare or legal review, add a [RISK_LEVEL] placeholder that adjusts the priority thresholds—for example, lowering the confidence threshold for CRITICAL classification when the cost of a missed contradiction is severe. Always validate the output JSON against the schema before presenting it to reviewers; a malformed handoff packet defeats the purpose of structured assembly.

This prompt is designed to sit at the final stage of a cross-format verification pipeline, after individual claim-evidence pairs have been scored and before a human reviewer opens the case. It consumes structured verification results from upstream prompts—text-to-table matches, chart-to-data reconciliations, audio-transcript fidelity checks—and assembles them into a single, prioritized handoff packet. The implementation harness must enforce a strict contract: the prompt receives only machine-verifiable inputs (claim objects, evidence snippets, confidence scores, format tags) and produces a structured reviewer packet. Do not pass raw source documents or unprocessed multimodal files directly to this prompt; upstream extraction and verification steps must complete first.

Wire this prompt as a post-verification aggregation step in your orchestration layer. The input payload should include a batch of verified claims, each with a claim_id, format_origin (e.g., text, chart, audio_transcript), verdict (e.g., supported, contradicted, unverifiable), confidence_score (0.0–1.0), evidence_snippets (with format-typed references and source URIs), and any uncertainty_flags raised by upstream verifiers. Validate the input schema before calling the model—reject batches missing required fields or containing unresolved evidence links. On the output side, validate the assembled packet against an expected JSON schema that includes reviewer_packet.priority_order, reviewer_packet.claims[] with reviewer_guidance, and reviewer_packet.uncertainty_summary. If validation fails, retry once with a repair prompt that includes the schema violation details; if it fails again, route to a human operator with the raw verification results and a failure log.

Model choice matters here. This prompt requires strong instruction-following and structured output reliability, not multimodal vision or audio processing. Use a model optimized for JSON generation and long-context assembly, such as gpt-4o or claude-3-5-sonnet with structured output mode enabled. Set temperature low (0.0–0.2) to preserve claim ordering and confidence-score fidelity. The prompt does not need tool use or retrieval—all evidence must be pre-assembled in the input context. Log every handoff packet with its input claims, model version, and validation status for auditability. In regulated domains, require human sign-off on the final packet before it enters a review queue. The primary failure mode is information overload: the model may include too many low-priority claims or bury critical contradictions. Mitigate this by enforcing a hard claim-count limit in the prompt constraints and testing with edge cases where 90% of claims are supported but 10% are high-severity contradicted—the packet must surface the contradictions first.