Output Confidence Justification Prompt

Use this prompt when an audit trail, compliance review, or downstream decision requires more than a numeric confidence score. It is designed for high-stakes workflows—such as regulated document review, clinical note summarization, or financial transaction analysis—where a model's output triggers an action like escalation, human review, or automated rejection. The primary job-to-be-done is generating a structured, human-readable rationale that cites specific evidence gaps, reasoning limitations, or source conflicts, making the model's uncertainty auditable and challengeable by a reviewer.

This prompt is ideal for compliance officers, audit teams, and AI safety engineers who need to log why a model was uncertain, not just how uncertain it was. The required context includes the original model output, the confidence level assigned, and the source material or reasoning chain that led to that output. You should not use this prompt for low-risk, high-volume classification where a simple confidence threshold is sufficient, or in latency-critical real-time applications where the added token generation for a justification would violate a time budget. It is also unnecessary when the model's output is purely creative or subjective, with no factual ground truth to anchor the justification.

Before implementing, confirm that your system already captures the raw confidence score and the model's output. The justification prompt acts as a post-hoc explainer, not a confidence estimator. If you need to generate the initial confidence score, pair this with a calibration prompt first. In production, always log the justification alongside the score and output for the same request ID. Avoid using this prompt as a substitute for human review in truly safety-critical decisions; instead, use it to make the human review process faster and more focused by pre-structuring the evidence of uncertainty.

This template is designed for compliance, audit, and safety engineering teams who need more than a single confidence score. It forces the model to decompose its own reasoning, identify specific evidence gaps, and justify the assigned confidence level. The output is a structured justification object that can be logged, reviewed, and compared against ground truth for faithfulness checks. Use this prompt when the cost of an unjustified high-confidence error is high—such as in clinical review, legal analysis, or financial audit workflows.

textCopy
System: You are an expert analyst. Your task is to provide a structured confidence justification for every answer you produce. You must never fabricate evidence or inflate confidence. If evidence is missing, contradictory, or ambiguous, you must state this explicitly.

User: Based on the provided [CONTEXT], answer the following [QUERY].

After your answer, append a `CONFIDENCE_JUSTIFICATION` block using the exact JSON schema below. Do not include any other text after the JSON block.

[OUTPUT_SCHEMA]
{
  "answer": "string (your full answer to the query)",
  "confidence_score": number (0.0 to 1.0),
  "confidence_level": "high" | "medium" | "low" | "unsafe",
  "justification": {
    "supporting_evidence": [
      {
        "source_id": "string (reference to [CONTEXT] chunk)",
        "relevance": "direct" | "indirect" | "inferred",
        "strength": "strong" | "moderate" | "weak"
      }
    ],
    "evidence_gaps": [
      "string (describe a specific missing piece of information needed to increase confidence)"
    ],
    "reasoning_limitations": [
      "string (describe a limitation in your own reasoning, such as ambiguity, conflicting sources, or domain complexity)"
    ],
    "alternative_interpretations": [
      "string (describe another plausible conclusion the evidence could support)"
    ]
  },
  "requires_human_review": boolean,
  "escalation_reason": "string (required if requires_human_review is true, otherwise null)"
}

[CONSTRAINTS]
- If no evidence supports a claim, `supporting_evidence` must be an empty array and `evidence_gaps` must describe what is missing.
- If `confidence_level` is "low" or "unsafe", `requires_human_review` must be true.
- Do not hallucinate source_ids. Only reference identifiers present in [CONTEXT].
- If [CONTEXT] is empty, set `confidence_score` to 0.0 and `confidence_level` to "unsafe".

[CONTEXT]
[INSERT CONTEXT HERE]

[QUERY]
[INSERT QUERY HERE]

To adapt this template, replace [CONTEXT] with your retrieved documents, database records, or source text, ensuring each chunk has a stable source_id. Replace [QUERY] with the user's question or task. The [OUTPUT_SCHEMA] and [CONSTRAINTS] blocks are critical for production use: they define the contract your application parser expects. For high-risk domains, add a [RISK_LEVEL] input that adjusts the threshold for requires_human_review. After deployment, validate that the source_id values in supporting_evidence actually exist in the provided context—this is the most common failure point and a direct check for hallucinated citations.

The Output Confidence Justification Prompt is not a standalone chat interaction—it is a compliance-facing component that must be embedded in a deterministic application harness. The harness is responsible for supplying the original output, the confidence score, the source context, and any model reasoning traces. The prompt itself produces a structured justification, but the harness must validate that justification before it enters an audit trail. Treat this prompt as a post-hoc explainability step that runs after the primary model response and confidence estimation are complete, not as a real-time user-facing feature.

Wire the prompt into a pipeline that executes after your primary model returns a confidence score below a configurable threshold (e.g., < 0.85) or when an audit flag is set on the interaction. The harness should assemble the [ORIGINAL_OUTPUT], [CONFIDENCE_SCORE], [SOURCE_EVIDENCE], and [REASONING_TRACE] placeholders from the upstream model call. After the justification is generated, run a faithfulness check: extract each evidence-gap claim from the justification and verify it against the provided source context using a separate entailment or NLI model. If the justification cites a gap that does not exist in the source material, flag it for human review. Log the raw justification, the faithfulness check result, and the reviewer decision in an append-only audit store with the interaction ID, timestamp, and model version.

For retry logic, implement a single retry with a stricter prompt variant if the first justification fails schema validation or contains hallucinated gap claims. Do not retry more than once—a second failure should escalate directly to a human reviewer with the full context packet. Model choice matters: use a model with strong instruction-following and low hallucination rates for justification generation (GPT-4, Claude 3.5, or equivalent). Avoid smaller or faster models here because the cost of an inaccurate audit justification outweighs the latency savings. If your system processes high volumes, batch non-urgent justifications and process them asynchronously, but keep real-time audit-sensitive interactions synchronous with a hard timeout of 10 seconds before falling back to a templated justification that a human must later amend.