Multimodal Source Alignment Verification Prompt

This prompt is for verification architects and pipeline engineers who need to determine whether multiple sources in different formats—text, tables, images, audio transcripts, video descriptions—describe the same event, entity, or claim. It produces alignment scores, contradiction flags, and a reconciled timeline. Use this when your verification pipeline ingests heterogeneous evidence and must decide if a witness statement, a spreadsheet row, and a video segment all refer to the same incident. The core job is pre-verification alignment: before you match claims to evidence, you must first confirm that the evidence pieces are about the same thing. Getting this wrong means downstream fact-checking operates on incorrectly merged or incorrectly separated source clusters, producing confident but meaningless verdicts.

The ideal user is building or operating an automated verification system that consumes multimodal inputs. You have already extracted claims and evidence objects from individual sources, and now you need to cluster them by real-world referent. The prompt expects structured inputs: each source object should carry a format type, extracted content, temporal markers, entity mentions, and any existing provenance metadata. Do not use this prompt for single-format claim verification, simple text-to-text comparison, or when sources are already normalized into a common schema—those are downstream tasks. Do not use it when you lack temporal or entity anchors; alignment without anchoring fields degrades into semantic similarity matching, which is the primary failure mode.

The primary risk is false-positive alignment: semantically similar but factually distinct sources being incorrectly merged. Two financial reports might both mention 'Q3 revenue decline' but refer to different companies, years, or product lines. A witness statement and a video transcript might both describe 'a blue vehicle turning left' but refer to different intersections hours apart. This prompt is designed to surface those distinctions through explicit contradiction checking and temporal reconciliation, not just topical clustering. Before deploying, build an eval set of known-to-be-distinct source pairs that share surface-level similarity, and measure your false-positive alignment rate. If it exceeds your pipeline's tolerance, add a human-review gate after alignment before evidence matching begins.

This prompt template is the core instruction set for a Multimodal Source Alignment Verification workflow. It is designed to be dropped into an AI harness that has already extracted structured content from each source (e.g., text from a PDF, transcribed speech from an audio file, OCR'd text from an image, or parsed rows from a CSV). The prompt forces the model to act as a skeptical alignment auditor, comparing the semantic content of each source against a central claim or event description. It does not assume the sources agree; its primary job is to measure the degree of alignment and surface contradictions.

textCopy
You are a skeptical alignment auditor. Your task is to determine whether the provided sources, which may be in different formats, describe the same underlying event, entity, or claim.

First, identify the central subject: [CENTRAL_CLAIM_OR_EVENT_DESCRIPTION].

Next, analyze the following sources. Each source is provided with its extracted content and a format label.

[SOURCE_1_FORMAT]: [SOURCE_1_CONTENT]
[SOURCE_2_FORMAT]: [SOURCE_2_CONTENT]
[SOURCE_3_FORMAT]: [SOURCE_3_CONTENT]
(Add or remove source blocks as needed)

For each source, extract the atomic claims it makes about the central subject.

Then, perform a pairwise comparison of the claims from all sources. For each pair, determine if the claims are:
- Aligned: They describe the same fact without contradiction.
- Partially Aligned: They overlap but have differences in detail, scope, or specificity.
- Contradictory: They assert mutually exclusive facts.
- Unrelated: They discuss different aspects of the subject without overlapping.

Based on this analysis, produce a final output in the following JSON format:
{
  "central_subject": "string",
  "overall_alignment_score": "number (0.0 to 1.0, where 1.0 is perfect alignment)",
  "contradiction_flags": [
    {
      "source_pair": ["source_1_format", "source_2_format"],
      "claim_1": "string",
      "claim_2": "string",
      "contradiction_type": "direct_factual | temporal | numerical | entity_mismatch",
      "severity": "critical | major | minor"
    }
  ],
  "reconciled_timeline": [
    {
      "event": "string",
      "timestamp": "ISO 8601 string or null",
      "supporting_sources": ["source_format"],
      "confidence": "high | medium | low"
    }
  ],
  "alignment_notes": "A concise summary of the strongest points of alignment and the most significant discrepancies."
}

[CONSTRAINTS]:
- Do not invent information to force alignment. If sources disagree, flag the contradiction.
- If a source's format introduces uncertainty (e.g., low-quality OCR), note this in the alignment_notes and reduce confidence in claims from that source.
- The reconciled_timeline should only include events that can be supported by at least one source. Do not hallucinate events.
- If no timestamp can be inferred for a timeline event, set the timestamp field to null.

To adapt this template, replace the bracketed placeholders with your specific data. The [CENTRAL_CLAIM_OR_EVENT_DESCRIPTION] is the anchor for the entire analysis; make it as specific as possible. The source blocks should contain pre-processed, clean text. Before integrating this prompt into a production pipeline, you must build a validation layer for the JSON output to ensure the schema is strictly followed and that the overall_alignment_score is a valid float. For high-stakes verification, always route outputs with critical severity contradictions or low confidence timelines for human review. The next step is to pair this prompt with a robust evaluation set containing known false-positive alignment cases—semantically similar but factually distinct sources—to ensure the model correctly identifies misalignment.

The Multimodal Source Alignment Verification Prompt is rarely a standalone tool. It operates as a critical step within a larger verification pipeline, typically invoked after claim extraction and evidence retrieval have produced candidate source pairs in different formats. The prompt's job is to determine whether two sources—say, a text transcript and a video segment, or a chart and a spreadsheet—actually describe the same event, entity, or claim, or whether they are merely semantically similar but factually distinct. This alignment decision gates downstream actions: if sources are aligned, they can be used for cross-format contradiction detection or evidence corroboration; if they are misaligned, the pipeline must avoid false-positive matches that would corrupt verification results.

To wire this prompt into an application, start by defining the input contract. The prompt expects a structured payload containing at minimum: a source pair with format-type labels (e.g., text, image, audio_transcript, table, chart, video_segment), the extracted claims from each source, and any available metadata such as timestamps, speaker IDs, or document section references. The application layer should normalize these inputs before calling the model—standardize date formats, resolve timezone offsets, and strip irrelevant markup. The model call itself should be wrapped in a validation layer that checks the output schema before the result enters the pipeline. The expected output includes an alignment score (0.0 to 1.0), a list of contradiction flags if alignment is high but discrepancies exist, and a reconciled timeline when temporal claims are present. If the output fails schema validation—missing required fields, scores outside bounds, or malformed JSON—the harness should retry with a repair prompt rather than silently accepting a broken result.

Model choice matters here. This prompt requires strong cross-modal reasoning and careful attention to detail, making it a good candidate for frontier models with multimodal capabilities when image or video sources are involved. For text-only source pairs, a strong text model may suffice. Implement a retry strategy with exponential backoff for transient failures, but cap retries at three attempts before escalating to a human review queue. Log every alignment decision with the full input payload, model response, validation result, and any retry attempts. This audit trail is essential for debugging false-positive alignments—the most common failure mode, where the model conflates semantically similar but factually distinct sources. For high-risk domains such as legal or financial verification, always route alignment scores in a middle band (e.g., 0.4 to 0.7) to human reviewers rather than accepting machine decisions at face value. The alignment score should never be treated as a binary threshold without understanding the distribution of scores across your specific source types and claim categories.

Testing this prompt before production deployment requires a curated evaluation set of source pairs with known alignment relationships. Include positive examples where sources genuinely describe the same event, negative examples where sources are topically similar but factually distinct, and edge cases such as sources that describe the same event but with contradictory details. Measure both alignment accuracy and contradiction detection recall. Pay special attention to format-specific failure modes: the model may over-weight textual similarity when comparing a chart to a text description, or may hallucinate visual details when aligning an image-based claim with a text source. Run evals after every prompt or model version change, and maintain a regression set of previously misclassified pairs. If your pipeline processes sources at scale, consider implementing a lightweight pre-filter that uses metadata heuristics—date proximity, entity overlap, or source provenance—to reduce the number of pairs that require full multimodal alignment verification, keeping latency and cost within budget.