Self-Critique

Self-Critique establishes a closed-loop feedback system within a single model inference session. The core mechanism involves:

• Initial Generation: The model produces a first-pass answer or reasoning chain (e.g., a Chain-of-Thought).
• Critical Evaluation: The model, following a meta-prompt, switches roles to act as an evaluator, scrutinizing its own output for logical fallacies, factual inaccuracies, or missed assumptions.
• Final Synthesis: Using the critique, the model generates a revised, improved final output. This creates a single-agent, multi-turn dialogue that mimics a human revising a draft, significantly improving output quality without external verification.

The technique relies on structured meta-instructions that force the model to adopt a critical perspective. Effective prompts explicitly define the evaluation criteria. For example:

• "Review the following solution for calculation errors."
• "Identify any unsupported assumptions in the argument below."
• "Check the consistency between the stated premises and the final conclusion." This shifts the model from a generative mode to an analytical mode. The prompt architecture is crucial; vague instructions like "Is this good?" yield poor results, while specific, role-based prompts ("Act as a rigorous peer reviewer") elicit meaningful self-assessment.

A primary utility of Self-Critique is identifying and correcting model hallucinations and reasoning breakdowns. The model is tasked to flag:

• Factual Contradictions: Internal inconsistencies within the generated text.
• Unsubstantiated Claims: Statements presented as fact without evidence in the provided context.
• Logical Non-Sequiturs: Conclusions that do not follow from the provided reasoning steps.
• Mathematical Errors: Mistakes in arithmetic or symbolic manipulation. By surfacing these issues in the critique phase, the final output has higher factual fidelity and logical coherence, making the technique vital for applications requiring high accuracy, such as technical analysis or summarization of complex documents.

Self-Critique is fundamentally different from using a separate, external model or tool for verification. Key differentiators include:

• Single-Model Paradigm: The same model parameters and knowledge base are used for both generation and critique. This is computationally efficient but means the critique is limited by the model's own knowledge and biases.
• No Ground Truth Required: Unlike supervised evaluation, the model critiques its own work without access to a canonical correct answer.
• Contrast with Self-Consistency: While Self-Consistency samples multiple independent reasoning paths and votes on answers, Self-Critique sequentially refines a single reasoning path. It is complementary to techniques like Chain-of-Verification (CoVe), which is a more structured, multi-step instantiation of the self-critique principle.

In agentic cognitive architectures, Self-Critique functions as a core reflection module. It is a building block for more complex loops:

• Planning Phase: An agent can generate a plan, critique it for feasibility, and then refine it before execution.
• Tool-Use Validation: After performing an action or API call, the agent can critique the result's validity before proceeding.
• Recursive Error Correction: Failed actions can trigger a self-critique loop to diagnose the cause and adjust strategy. This makes the agent self-correcting and more robust. It is a simpler, more immediate form of reflection compared to Reinforcement Learning from AI Feedback (RLAIF), which requires training a separate reward model.

Self-Critique is not a panacea and has inherent limitations:

• Complacent Agreement: The model may fail to identify its own errors, producing a shallow or affirming critique that misses fundamental flaws—a form of confirmation bias.
• Knowledge Boundary: The model cannot critique information outside its training data or identify subtle factual errors it itself believes to be true.
• Critique Hallucinations: The model may invent problems that don't exist or propose incorrect corrections, potentially degrading the final answer.
• Prompt Sensitivity: Performance is highly dependent on the exact phrasing of the critique instruction. Mitigations include prompt ensembling (trying multiple critique prompts) and hybrid approaches that combine self-critique with retrieval-augmented verification for factual grounding.

A structured fact-checking method where a model:

• Generates an initial baseline answer.
• Plans a set of verification questions to audit its own claims.
• Executes those verifications, often via retrieval.
• Produces a final, revised answer based on the audit.

Key Difference: While Self-Critique is a single review step, CoVe is a multi-phase, planned verification cycle explicitly focused on factual accuracy.

A training paradigm where a model receives reward signals or feedback for each individual step in a reasoning chain, not just the final output. This is often implemented using a Process Reward Model (PRM).

Relation to Self-Critique: Process Supervision trains a model's internal critique capability. Self-Critique is the inference-time application of a similar step-wise evaluation skill, often emerging from such training.

Quantitative measures that evaluate whether a model's generated reasoning steps are:

• Logically consistent with each other.
• Factually correct and grounded.
• Genuinely causal in leading to the final answer (not post-hoc rationalizations).

Application: These metrics (e.g., entailment-based scores) are used to automatically assess the quality of a model's Self-Critique, determining if the critique is itself faithful.

A framework that interleaves verbalized reasoning traces with actionable steps (tool/API calls). The model operates in a loop: Thought → Act → Observe.

Critique Integration: In advanced ReAct agents, a Self-Critique step can be inserted into the 'Thought' phase to evaluate the last observation or planned action before execution, leading to more robust and error-aware agents.

A decoding strategy that improves reliability by:

• Sampling multiple, diverse reasoning paths (Chain-of-Thoughts) for a single problem.
• Generating a final answer from each path.
• Selecting the most frequent final answer via majority vote.

Contrast with Self-Critique: Self-Consistency aggregates outputs from different reasoning attempts. Self-Critique refines a single reasoning attempt through internal review. They are complementary techniques.

A prompt engineering technique that structures a task with graduated hints, decompositions, or meta-instructions to guide a model. A common pattern is to explicitly instruct the model to work in phases: 'First, plan your approach. Second, execute the steps. Third, review your work for errors.'

Foundation for Self-Critique: Explicit scaffolding in a prompt (e.g., 'Critique your initial answer...') is the primary method for eliciting Self-Critique behavior from models not explicitly trained for it.