Source-Attribution Audit Prompt for Multi-Document Synthesis

This prompt is designed for research, intelligence, and legal teams who synthesize findings across multiple documents and need a verifiable chain of custody for every claim. The job-to-be-done is post-generation auditing: after a model produces a synthesized output from several source documents, this prompt maps each factual assertion back to its originating document, identifies claims with no source match, and produces an attribution matrix. The ideal user is an analyst, editor, or product manager responsible for the accuracy of AI-generated briefs, reports, or digests before they reach decision-makers or external audiences.

The prompt requires three concrete inputs to function: a synthesized output text, a set of source documents with unique identifiers, and a defined attribution schema. Without all three, the audit will be incomplete. The source documents must be provided in full or as chunked passages with stable IDs—this prompt does not retrieve sources itself. It assumes the synthesis was already generated by another system or human. The output is an attribution matrix where each claim receives a status of grounded, partially-grounded, or unsupported, along with the specific source ID and quoted evidence for grounded claims. This is not a fact-checking prompt against external truth; it only verifies whether a claim can be traced to the provided source set.

Do not use this prompt when the source documents are unavailable, when the synthesis is purely interpretive opinion rather than factual assertion, or when the output format is unstructured narrative without discrete claim boundaries. It is also inappropriate for real-time chat applications where latency constraints prevent a full audit pass. For high-stakes domains such as legal filings, clinical summaries, or financial disclosures, the attribution matrix this prompt produces must still undergo human review before publication—the prompt identifies grounding gaps but does not guarantee the underlying sources are themselves accurate. If you need to verify source authenticity or detect fabricated citations within the sources themselves, pair this prompt with the RAG Citation Audit Prompt for Fabricated Sources from the same content group.

The following prompt is designed to be dropped into a production pipeline after a multi-document synthesis step. It forces the model to map every claim in a synthesized output back to its originating source document, identify claims with no source match, and produce a structured attribution matrix. The template uses square-bracket placeholders that your application must populate before sending the request. Do not use this prompt for real-time chat where latency is critical—the audit step adds a full inference pass and is best suited for asynchronous or batch validation workflows.

textCopy
You are a source-attribution auditor. Your task is to analyze a synthesized output against a set of provided source documents and produce an attribution matrix.

## INPUT

### Synthesized Output
[SYNTHESIZED_OUTPUT]

### Source Documents
[SOURCE_DOCUMENTS]

### Attribution Threshold
[ATTRIBUTION_THRESHOLD]

## INSTRUCTIONS

1. Extract every discrete factual claim from the Synthesized Output. A claim is a single verifiable assertion about the world, not an opinion or stylistic choice.
2. For each claim, search the Source Documents for supporting evidence. A claim is "attributed" if at least one source document contains information that directly supports the claim. A claim is "partially attributed" if some but not all elements of the claim are supported. A claim is "unattributed" if no source document supports it.
3. For attributed and partially attributed claims, cite the specific source document ID and the relevant excerpt that supports the claim.
4. For unattributed claims, mark them for human review and note whether the claim appears plausible but unsourced, or contradictory to source material.
5. Do not invent sources. If a claim cannot be matched to a provided source document, it must be marked unattributed.

## OUTPUT SCHEMA

Return a JSON object with the following structure:
{
  "attribution_matrix": [
    {
      "claim_id": "string",
      "claim_text": "string",
      "attribution_status": "attributed | partially_attributed | unattributed",
      "source_document_id": "string | null",
      "source_excerpt": "string | null",
      "attribution_confidence": "high | medium | low",
      "review_required": true | false,
      "review_reason": "string | null"
    }
  ],
  "summary": {
    "total_claims": "number",
    "attributed_claims": "number",
    "partially_attributed_claims": "number",
    "unattributed_claims": "number",
    "claims_requiring_review": "number"
  }
}

## CONSTRAINTS

- Do not modify the Synthesized Output. Only audit it.
- If a source document is ambiguous, mark the claim as partially attributed and explain the ambiguity in review_reason.
- If the Synthesized Output contains no factual claims, return an empty attribution_matrix with summary totals set to zero.
- If fewer than [ATTRIBUTION_THRESHOLD] percent of claims are attributed, set review_required to true for the entire output and include a top-level warning.

To adapt this template, replace [SYNTHESIZED_OUTPUT] with the full text of the model-generated synthesis your system produced. [SOURCE_DOCUMENTS] should be a structured list of source objects, each with a unique ID and the full text of the source—this is critical because the model needs both the ID for citation and the text for evidence matching. [ATTRIBUTION_THRESHOLD] is a number between 0 and 100 representing the minimum acceptable attribution percentage before the entire output is flagged for review. For high-risk domains like legal, medical, or financial reporting, set this threshold to 90 or above and always route unattributed claims to a human review queue. For lower-risk internal briefings, a threshold of 70 may be acceptable with automated logging of unattributed claims. If your source documents are large, consider chunking them and including chunk IDs in the source document list to improve citation precision. Always validate the output JSON against the schema before passing it downstream—malformed attribution matrices are a common failure mode when the model encounters ambiguous claims or very long source lists.

The Source-Attribution Audit Prompt is designed to operate as a post-generation validation step in a multi-document synthesis pipeline. It should be invoked after a primary synthesis model produces a draft output, but before that output reaches an end user or downstream database. The harness receives the synthesized text and the full set of source documents as inputs, then returns an attribution matrix mapping each claim to its originating source or flagging it as unsupported. This is not a real-time, user-facing prompt; it is a batch or near-batch audit step that runs with higher latency tolerance and stricter correctness requirements.

Wire this prompt into your application as a dedicated audit service with a clear API contract. The service accepts a JSON payload containing synthesized_output (the text to audit) and source_documents (an array of objects with document_id and content fields). The prompt returns a structured JSON response with a claims array, where each claim includes claim_text, source_document_id (or null), supporting_quote (or null), and attribution_status (one of grounded, partially_grounded, or unsupported). Implement a JSON schema validator on the response before processing it further. If validation fails, retry once with the same inputs and a stronger constraint instruction appended to the prompt. If the second attempt fails, log the failure and escalate for human review rather than silently dropping the audit. For high-stakes domains like legal, clinical, or financial synthesis, always route outputs with any unsupported claims to a human review queue before publication.

Model choice matters for this workflow. Use a model with strong instruction-following and long-context handling, such as Claude 3.5 Sonnet or GPT-4o, because the prompt requires careful cross-referencing between the synthesis and multiple source documents. Avoid small or fast models that may hallucinate attribution mappings. Set temperature=0 to maximize deterministic behavior, and ensure your context window can accommodate the full synthesis plus all source documents. If the combined input exceeds the context limit, chunk the synthesis by section or paragraph and run the audit in parallel batches, then merge the results. Log every audit run with a unique audit_id, the model version, the input hash, and the count of grounded versus unsupported claims. This log becomes your audit trail for compliance and debugging. Finally, build a monitoring dashboard that tracks the unsupported claim rate over time—an increasing rate signals either source retrieval degradation or synthesis model drift that requires investigation.