Structured Conflict Report Generation Prompt

This prompt is designed for compliance officers, audit teams, and AI engineers building systems that must surface contradictory evidence across documents in a machine-readable format. Use it when you have multiple source documents that disagree on factual claims, regulatory interpretations, financial figures, or policy statements, and you need a structured JSON report that can feed into review queues, ticketing systems, or compliance dashboards. The prompt generates conflict reports with source identifiers, claim pairs, conflict categories, severity scores, and recommended actions. It assumes you have already retrieved the relevant document passages and can provide them as context.

The ideal user is someone integrating this prompt into an automated pipeline where downstream systems consume structured conflict data. For example, a compliance engineer might wire this into a document review system that flags contradictions in vendor contracts before approval. The prompt requires pre-retrieved context passages with source metadata—it does not perform retrieval itself. You must provide document IDs, passage text, and any relevant metadata such as dates, jurisdictions, or authoritativeness scores. The output schema is designed for machine consumption: each conflict entry includes source_a_id, source_b_id, claim_a, claim_b, conflict_category, severity_score, and recommended_action. This structure enables direct ingestion into review queues, ticketing systems like Jira, or compliance dashboards without post-processing.

Do not use this prompt when you need a natural-language summary for human readers only, when sources are fully aligned, or when the conflict resolution logic requires domain-specific legal or regulatory judgment that must be performed by a qualified professional. This prompt identifies and categorizes conflicts but does not resolve them—resolution decisions remain with human reviewers. Also avoid this prompt when you lack source metadata, as the output depends on traceable source identifiers. If your use case involves temporal conflicts where newer documents supersede older ones, pair this prompt with the Temporal Conflict Resolution Prompt to handle effective-date precedence before generating the conflict report. For high-stakes domains like healthcare or legal, always route the output through a human review step before taking action on the conflicts.

This prompt template is designed for compliance officers, audit teams, and knowledge base operators who need structured, machine-readable conflict reports from multi-source evidence. It instructs the model to analyze provided documents, identify contradictory claims, and output a strict JSON schema suitable for downstream workflow integration, review queues, or automated escalation systems. The template uses square-bracket placeholders that you must replace with your actual inputs before sending to the model.

textCopy
You are a structured conflict report generator. Your task is to analyze the provided source documents and identify contradictory claims, inconsistencies, or factual disagreements. You must output a valid JSON object conforming to the schema described below. Do not include any text outside the JSON object.

## INPUT DOCUMENTS
[DOCUMENTS]

## OUTPUT SCHEMA
You must output a JSON object with the following structure:
{
  "report_id": "string",
  "generated_at": "ISO-8601 timestamp",
  "conflicts": [
    {
      "conflict_id": "string",
      "category": "factual_contradiction | temporal_conflict | definitional_disagreement | methodological_variance | jurisdictional_conflict | data_quality_issue",
      "severity": "critical | major | minor | informational",
      "claim_pairs": [
        {
          "claim_a": {
            "source_id": "string",
            "source_name": "string",
            "excerpt": "string (exact quote from source)",
            "location": "string (page, section, or paragraph reference)"
          },
          "claim_b": {
            "source_id": "string",
            "source_name": "string",
            "excerpt": "string (exact quote from source)",
            "location": "string (page, section, or paragraph reference)"
          },
          "conflict_description": "string (concise explanation of the contradiction)",
          "resolution_status": "unresolved | resolved_by_precedence | resolved_by_credibility | escalated"
        }
      ],
      "recommended_action": "string (specific next step for the reviewer)",
      "escalation_required": true | false,
      "escalation_reason": "string | null"
    }
  ],
  "summary": {
    "total_conflicts_found": "integer",
    "critical_count": "integer",
    "major_count": "integer",
    "minor_count": "integer",
    "informational_count": "integer",
    "overall_assessment": "string (brief summary of conflict landscape)"
  }
}

## CONSTRAINTS
- Only report conflicts where there is genuine contradiction, not stylistic differences or paraphrasing.
- Every claim excerpt must be a verbatim quote from the source document.
- If no conflicts are found, return an empty conflicts array with a summary explaining why.
- Do not fabricate conflicts. If evidence is insufficient to confirm a contradiction, do not include it.
- Severity must reflect domain impact, regulatory risk, and decision criticality.
- For [RISK_LEVEL] contexts, flag all conflicts as requiring human review.

To adapt this template, replace [DOCUMENTS] with your actual source texts, each clearly labeled with a unique source_id and source_name. For high-stakes domains such as legal or financial compliance, set [RISK_LEVEL] to high to enforce mandatory human review on all conflicts. Before deploying, validate the model's output against the JSON schema using a programmatic validator. Implement a retry loop with a repair prompt if parsing fails. For production systems, log every generated report with the input document hashes and model version for auditability. Always route critical severity conflicts to a human review queue before any automated action is taken.

The Structured Conflict Report Generation prompt is designed to be called from an application layer that already has retrieved documents, source metadata, and a defined output schema. The prompt itself is stateless: it receives a set of claims and source passages, then returns a JSON conflict report. The application is responsible for assembling the input context, calling the model, validating the output against the expected schema, and deciding what happens next—retry, repair, escalate, or store. This prompt is not a chatbot. It is a single-turn structured generation call that should be treated like an API endpoint with strict input and output contracts.

Wire the prompt into a pipeline that performs the following steps. Pre-call: assemble the [CLAIMS] array from upstream extraction or fact-checking steps, attach [SOURCE_DOCUMENTS] with unique identifiers and full passage text, and inject [OUTPUT_SCHEMA] as the exact JSON Schema you expect back. Model selection: use a model with strong structured output support (GPT-4o, Claude 3.5 Sonnet, or equivalent) and enable structured output mode or JSON mode if available. Post-call validation: validate the returned JSON against your schema immediately. Check that conflict_id values are unique, source_a_id and source_b_id reference real source identifiers from the input, severity_score falls within the defined range, and recommended_action matches your allowed enum. If validation fails, route to a repair prompt or retry with the validation error message appended as [PREVIOUS_ERROR]. Logging: log the full prompt, response, validation result, and any retry attempts. For compliance workflows, store the conflict report alongside the source document versions and timestamps used at generation time. Human review gate: for conflicts with severity_score above a configurable threshold or recommended_action values of escalate or legal_review, route the report to a review queue before any downstream action is taken. Do not auto-resolve conflicts in regulated domains.

Common failure modes in the harness include: schema drift where the model returns valid JSON that doesn't match your expected field names; hallucinated source identifiers that don't exist in the input; severity inflation where every conflict is marked critical; and false negatives where genuine contradictions are missed. Mitigate these with eval suites that test against known conflict pairs, schema conformance checks, and periodic human audit of a sample of generated reports. The prompt is a component, not the whole system—the harness is where reliability, auditability, and safety are enforced.