Constitutional Self-Review

The core mechanism is the application of a predefined constitution—a set of explicit rules or principles—against which the model's initial output is judged. This is distinct from open-ended self-critique. The constitution acts as a deterministic checklist, often including items like:

• Safety: 'Does this output contain harmful instructions?'
• Legality: 'Does this advice violate any mentioned jurisdiction's laws?'
• Ethics: 'Does this response show unfair bias?'
• Factuality: 'Are all claims verifiable against the provided context?' The model is prompted to score or flag its output for compliance with each constitutional rule.

The process is triggered by specific, measurable failures identified during the rule-based evaluation. If the model's self-review detects a violation of any constitutional principle, it must initiate a correction cycle. This moves beyond subjective 'improvement' to mandated revision based on breached guardrails. For example, if the constitution forbids providing medical dosage advice and the initial output does so, the self-review must flag this and the subsequent generation must omit or correct the violating content. This creates a predictable, auditable link between violation detection and corrective action.

A key output of constitutional self-review is an explicit audit log. The model is instructed to not only produce a revised output but also to document its review process. This trace typically includes:

• The specific constitutional rule(s) that were evaluated.
• The verdict for each rule (e.g., 'PASS', 'FAIL', 'PARTIAL').
• For any failures, a brief explanation of the identified violation.
• A summary of the changes made to address the violation. This structured trace provides transparency, enables external validation, and is crucial for debugging and refining both the constitution and the prompt itself.

The architecture often employs a clear separation between the review phase and the revision phase. While a single model can perform both, the prompt design treats them as distinct, sequential tasks. First, the model acts as an auditor against the constitution. Then, using the audit findings as input, it acts as an editor to generate the compliant output. This separation reduces the likelihood of the model 'reasoning away' its own errors during a single, continuous generation. In advanced implementations, this can be operationalized using a multi-agent pattern with separate 'reviewer' and 'editor' instances or personas.

Unlike general fact-checking, constitutional self-review in Retrieval-Augmented Generation (RAG) contexts is explicitly bound to the provided source documents. The constitution includes rules like: 'Every factual claim must be attributable to a citation from the provided context.' The self-review step involves a grounding check, where the model must cross-reference its statements with source excerpts. This directly mitigates hallucination by forcing the model to verify its output against the authorized knowledge base, not its internal training data. Failure to find a source triggers a correction to qualify or remove the ungrounded claim.

The final characteristic is the closed-loop guarantee. The process does not end after a single revision. The prompt architecture often includes a final constraint re-application step, where the revised output is run through the same constitutional rules again. This ensures the corrective edits did not introduce new violations or fail to fully resolve the original issue. The goal is to achieve a state where the output passes all constitutional checks, providing a higher-confidence guarantee of compliance than a single, un-reviewed generation. This aligns with evaluation-driven development principles, baking the evaluation criteria directly into the generation workflow.

A model is given a constitution prohibiting harmful, unethical, or dangerous advice. Before finalizing a response to a user query (e.g., 'How can I hack into a network?'), the model performs a self-review: it checks its draft answer against the constitutional rules, identifies any violation (e.g., providing illegal instructions), and revises the output to instead refuse the request or redirect to ethical cybersecurity resources. This creates an internal safety layer without relying solely on external filters.

• Key Principle: 'Do not provide instructions for illegal activities.'
• Outcome: The model autonomously rejects harmful requests, increasing deployment safety.

In financial or healthcare chatbots, a regulatory constitution is defined with rules based on laws like GDPR, HIPAA, or FINRA regulations. When generating a response about data handling or financial advice, the model cross-references its output against this rule set.

For example, a draft stating 'Share the patient's full history' would be flagged for violating the constitutional rule: 'Do not disclose Protected Health Information without explicit consent.' The model then revises the output to be generic or to request proper authorization. This enables automated compliance checking within the generation loop.

An AI resume screening tool uses constitutional self-review to combat demographic bias. Its constitution includes principles like: 'Do not infer characteristics about a candidate based on university name alone' and 'Ensure job requirement alignment is based on skills, not presumed cultural fit.'

For each evaluation, the model generates a preliminary assessment, then reviews it against these fairness rules. If it detects a bias (e.g., overly weighting a prestigious school), it revises the rationale to focus on quantified experience. This implements proactive fairness guardrails directly in the model's reasoning process.

In a Retrieval-Augmented Generation (RAG) system, the constitution mandates: 'Every factual claim must be attributable to a retrieved source chunk.' The model's self-review step involves listing each factual statement in its draft and verifying a source supports it.

If a claim lacks a source (a potential hallucination), the model must either remove it, mark it as unsupported, or re-query the knowledge base. This creates a self-enforced citation mechanism, significantly improving output veracity and aligning with enterprise needs for accuracy.

Companies deploy constitutional self-review to maintain consistent brand communication. The constitution contains rules on tone (e.g., 'professional yet approachable'), terminology (e.g., 'use "client" not "customer"'), and prohibited phrases.

A model drafting a marketing email first generates content, then reviews it against this style guide. It might flag a sentence as 'too casual' or for using a deprecated product name, and then rewrite it. This automates quality assurance for generative content, ensuring scalability without constant human editing.

When a model is prompted to generate JSON for an API, the constitution includes the exact JSON schema with required fields, data types, and value constraints. The self-review acts as a built-in validator.

The model generates a JSON draft, then checks it against the schema rules (e.g., 'price' must be a positive number). If a field is missing or a value is of type string instead of array, the model corrects it. This ensures deterministic formatting and integration-ready outputs, reducing post-processing errors in automated pipelines.

A self-correction loop is a prompting architecture where a language model is instructed to iteratively critique and revise its own output. Unlike a one-step review, this creates a feedback cycle, often involving multiple turns of generation and evaluation, to progressively improve accuracy, coherence, or adherence to constraints. It is the overarching process that constitutional self-review often operates within.

A self-critique prompt is the core instruction that directs a language model to analyze and evaluate the quality, correctness, or potential flaws in its own generated response. This is the fundamental building block for constitutional self-review, where the critique is specifically guided by a set of principles (the constitution). The prompt typically asks the model to act as a reviewer or critic of its initial draft.

Constraint re-application is a critical final step in many self-correction workflows. After generating a revised output, the model is prompted to systematically verify that the new text still satisfies all initial guardrails, rules, and boundary conditions specified in the original prompt. In constitutional self-review, this means explicitly checking the final answer against each rule in the constitution to ensure no violations were introduced during revision.

Multi-agent self-review is an advanced self-correction architecture that simulates a panel of experts. Instead of a single model performing its own critique, multiple instances or personas of a language model (e.g., a 'safety reviewer,' a 'logic reviewer,' a 'completeness reviewer') are prompted to analyze the same output. Their collective feedback is then synthesized to produce a final, consensus-driven revision. This can be seen as a distributed form of constitutional review.

The critique-generate cycle is the fundamental two-phase pattern of most self-correction loops. In the first phase (critique), the model produces an analysis of a draft response, identifying errors or areas for improvement. In the second phase (generate), the model uses that critique as input to produce a new, improved version of the output. Constitutional self-review formalizes the 'critique' phase by providing the specific constitutional rules as the evaluation criteria.

A hallucination self-check is a specialized type of self-correction instruction focused on factual grounding. It directs a language model to verify that all factual claims, names, dates, or numerical data in its output are supported by its source context or reliable training data, flagging potential fabrications. This is a common and critical rule within a safety or accuracy-focused constitution, aiming to mitigate one of the most significant failure modes of generative AI.