Multi-Policy Conflict Resolution Prompt for Violations

This prompt is designed for compliance engineers and trust and safety architects who must resolve situations where a single AI behavior triggers multiple policies that offer conflicting guidance. The core job-to-be-done is not just detecting a violation, but producing a structured conflict analysis that identifies the applicable policies, pinpoints the specific tension points between them, determines which policy takes precedence, and recommends a resolution path. The ideal user is someone who already has a defined policy library and needs a repeatable, auditable method for handling policy collisions without hardcoding every possible combination in application logic.

Use this prompt when your guardrail system has flagged an output or action that sits at the intersection of two or more policies with contradictory requirements—for example, a refusal policy that demands blocking a response versus a transparency policy that requires explaining why the block occurred. It is appropriate when the conflict is non-trivial and requires documented reasoning that a human reviewer or auditor can later inspect. The prompt requires the full text of the conflicting policies, the violation context, and any existing severity classifications as inputs. It is not a replacement for a policy hierarchy document; rather, it operationalizes that hierarchy in a specific case.

Do not use this prompt for simple, single-policy violations where a standard escalation template suffices. Avoid it in real-time, latency-sensitive enforcement paths where a sub-100ms decision is required; this is an analysis prompt designed for asynchronous review queues and post-detection adjudication. The output is a structured conflict resolution record, not an enforcement action. Always route the resolution recommendation to a human reviewer when the conflict involves high-severity safety policies, regulatory exposure, or novel policy intersections that lack precedent. The next step after generating the conflict analysis is to attach it to the violation record and submit it to the appropriate review queue with the unresolved tension points clearly flagged.

This template is designed for compliance engineers and trust and safety teams who need to resolve situations where an AI system's behavior triggers multiple policies that offer conflicting guidance. The prompt forces the model to identify all applicable policies, articulate the specific points of tension, apply a defined precedence hierarchy, and recommend a single, defensible resolution. Use this when a violation has already been detected and classified, but the required action is ambiguous because two or more policies pull in different directions.

textCopy
You are a compliance analysis engine. Your task is to resolve conflicts when multiple policies apply to a single guardrail violation and their guidance is contradictory.

## INPUT
[VIOLATION_RECORD]

## APPLICABLE POLICIES
[POLICY_LIST]

## POLICY HIERARCHY
[PRECEDENCE_RULES]

## OUTPUT SCHEMA
{
  "conflict_id": "string",
  "policies_in_conflict": [
    {
      "policy_name": "string",
      "policy_id": "string",
      "guidance": "string",
      "required_action": "string"
    }
  ],
  "tension_points": [
    {
      "point": "string",
      "policy_a": "string",
      "policy_b": "string",
      "description_of_conflict": "string"
    }
  ],
  "precedence_analysis": {
    "dominant_policy": "string",
    "rationale": "string",
    "overridden_policies": ["string"],
    "hierarchy_rule_applied": "string"
  },
  "recommended_resolution": {
    "action": "string",
    "justification": "string",
    "residual_risk": "string",
    "requires_human_approval": boolean
  },
  "confidence": "high|medium|low"
}

## CONSTRAINTS
- If no conflict exists, return a single-policy analysis with "conflict_detected": false.
- If the hierarchy does not clearly resolve the conflict, set confidence to "low" and set requires_human_approval to true.
- Always cite specific policy clauses or IDs in your rationale.
- Do not invent policies or precedence rules not present in the input.
- If a policy is regulatory or legal in nature, it automatically outranks internal policies unless the hierarchy explicitly states otherwise.

## EXAMPLES
[FEW_SHOT_EXAMPLES]

## RISK LEVEL
[RISK_LEVEL]

To adapt this template, replace the square-bracket placeholders with your operational data. [VIOLATION_RECORD] should contain the structured output from your detection prompt, including the violation type, severity, and evidence excerpt. [POLICY_LIST] must include the full text or structured representation of every policy flagged as applicable. [PRECEDENCE_RULES] is critical: define your organization's hierarchy explicitly (e.g., 'Legal/Regulatory > Safety > Privacy > Content Quality'). Provide [FEW_SHOT_EXAMPLES] that demonstrate correct conflict resolution, especially for known edge cases like safety-vs-privacy tensions. Set [RISK_LEVEL] to 'high' if the violation involves regulated data, minors, or financial impact, which should force requires_human_approval to true in ambiguous cases. Before deploying, validate the output against a golden set of adjudicated conflicts to ensure the model respects your hierarchy consistently and does not hallucinate policy clauses.

This prompt is not a standalone chat interaction; it is a decision-support module inside a larger compliance review pipeline. The typical integration point is after a guardrail violation detection system has flagged an output and before a human compliance officer makes a final adjudication. The application should assemble the required inputs—the original AI output, the list of triggered policies, and any relevant context—and inject them into the prompt's placeholders. The model's response should be treated as a structured recommendation, not an automated decision. The output must be logged immutably as part of the audit trail, including the model version, timestamp, and the raw prompt used.

Validation is critical before the analysis reaches a human reviewer. The application layer must parse the model's JSON output and confirm that every policy listed in the applicable_policies array exists in the input policy set, that the precedence_determination field references only those policies, and that the recommended_resolution is non-empty. If the model hallucinates a policy name or fails to resolve the conflict, the system should retry once with a stricter instruction to ground all references in the provided policy text. After a second failure, the item should be escalated to a human with a flag indicating an unresolvable policy conflict, bypassing the model's recommendation. For high-stakes domains like healthcare or finance, consider routing all severity: critical conflicts directly to human review regardless of model confidence.

Model choice matters here. Use a model with strong reasoning and instruction-following capabilities, such as GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro. Avoid smaller or faster models that may collapse the nuanced distinction between conflicting policies into a generic 'comply with all' answer. Set the temperature low (0.0–0.2) to maximize deterministic, repeatable analysis. Log the conflict_analysis and precedence_determination fields separately so that compliance teams can later query for patterns—for example, how often a data retention policy overrides a transparency policy. The human review interface should display the original violation, the model's conflict analysis, and clear accept/override/reject buttons. Every override must capture the reviewer's justification and identity, feeding back into the audit trail and future policy refinement cycles.