Factual Consistency Self-Correction Prompt

This prompt is designed for AI engineers and platform developers embedding self-correction into agent loops and post-generation validation pipelines. The primary job-to-be-done is to detect and resolve internal contradictions, timeline errors, and factual inconsistencies within a single model output—without relying on external retrieval or source documents. Use this when a generated response contains multiple claims that may conflict with each other, when you need a structured before/after diff for audit trails, or when you must enforce internal coherence as a quality gate before delivering output to downstream systems or users.

The ideal deployment context is a production harness where a validator has already flagged an output for potential inconsistency, or where internal coherence is a hard requirement for compliance and debugging. The prompt instructs the model to review its own output, identify contradictions, and produce a corrected version alongside a structured diff. This is not a substitute for RAG grounding or external fact-checking against source documents—it only corrects inconsistencies within the output itself. If your workflow requires verification against a knowledge base, use the RAG Hallucination Recovery Prompt or Claim Extraction and Source Verification Prompt instead. If the output contains unsupported assertions that cannot be resolved by internal cross-checking, escalate to the Missing Evidence Escalation Prompt.

Before using this prompt, ensure you have the original model output available as input and a defined output schema for the correction record. The prompt works best when the original output is self-contained and the contradictions are detectable through internal comparison—for example, conflicting dates, inconsistent entity names, or logical contradictions between claims. Do not use this prompt when the output is intentionally speculative, when contradictions are acceptable (e.g., brainstorming), or when the model lacks sufficient context to detect its own errors. For high-stakes domains such as healthcare, legal, or finance, always route corrected outputs through human review before finalization. The next section provides the copy-ready prompt template you can adapt for your harness.

This template is designed to be injected into a post-generation validation step within an agent loop or an output processing pipeline. It forces the model to act as a consistency auditor on its own previously generated text. The prompt strictly limits the review to internal logical conflicts—timeline errors, entity mismatches, and self-contradictions—and explicitly forbids checking against external world knowledge. This constraint keeps the correction loop fast and prevents the model from introducing new hallucinations while trying to 'fix' perceived factual gaps.

textCopy
Review the following model output for internal factual consistency. Identify any contradictions, timeline errors, entity inconsistencies, or logical conflicts within the output itself. Do not check against external sources. Only flag inconsistencies where the output contradicts itself. For each inconsistency found, explain the conflict and propose a correction. Then produce a fully corrected version of the output. Return your analysis in the specified JSON format with a before/after diff.

[OUTPUT_TO_REVIEW]

[OUTPUT_SCHEMA]

To adapt this prompt, replace the [OUTPUT_TO_REVIEW] placeholder with the raw text generated in the previous step. The [OUTPUT_SCHEMA] placeholder must be replaced with a strict JSON schema definition that includes fields for inconsistencies (an array of objects with conflict_description and proposed_correction) and corrected_output. For high-risk domains, ensure the application layer logs both the original and corrected outputs for audit trails before proceeding. Do not use this prompt to verify facts against a knowledge base; use a dedicated Retrieval-Augmented Generation (RAG) fact-checking prompt for that purpose.

Before deploying, test this prompt against a golden dataset of outputs containing known internal contradictions (e.g., a paragraph that changes a person's name mid-way or reverses a timeline). Validate that the model's JSON output strictly conforms to the provided schema. A common failure mode is the model 'correcting' subjective style choices instead of objective logical breaks; mitigate this by adding explicit negative examples in the system prompt if the base template drifts.

The Factual Consistency Self-Correction Prompt is designed to operate as a post-generation validation step within an agent loop or an API response pipeline. It should not be the first prompt a user sees. Instead, wire it as a secondary call that receives the original model output and the source context, then returns a corrected version alongside a structured diff. This separation keeps the primary generation fast and focused while the correction step handles accuracy enforcement. The prompt expects two critical inputs: the [ORIGINAL_OUTPUT] to audit and the [SOURCE_CONTEXT] that serves as ground truth. Without both, the self-correction instruction will either hallucinate corrections or fail to detect real inconsistencies.

When integrating this prompt into an application harness, implement a validator gate before the correction step. Parse the model's response for the corrections_made boolean and the corrections array. If corrections_made is false, pass the original output through without modification. If true, apply the corrected text from corrected_output and log the full diff object for audit purposes. For high-stakes domains, insert a human review queue when the severity field in any correction entry is critical or when more than a configurable threshold of claims are flagged. This prevents automated rewrites from introducing new errors during the correction pass. Use structured logging to capture the original output, the correction diff, and the final output in separate fields so downstream systems can trace every change.

For retry logic, implement a maximum of two correction attempts. After the first correction, run the corrected output through the same Factual Consistency Self-Correction Prompt again with the identical source context. If the second pass returns corrections_made: false, accept the output. If it still detects inconsistencies, escalate rather than retry further—log the failure, attach both correction diffs, and route to a human review queue or a fallback response indicating the system could not produce a verified answer. Model choice matters here: use a capable instruction-following model (such as Claude 3.5 Sonnet or GPT-4o) for the correction step, even if the primary generation uses a smaller model. The correction task requires precise comparison and disciplined output formatting. Set temperature to 0 or a very low value to minimize variance in the audit pass. Finally, wire the before_after_diff output into your observability stack so you can track hallucination patterns, correction rates, and model drift over time without manual spot-checking.