Self-Critique Loop

The core architectural feature is the use of a distinct reasoning component, often a specialized prompt or a dedicated critic model, to evaluate the primary agent's output. This separation of concerns prevents the generation logic from being biased by its own creation process. For example, an agent might use a prompt like: 'Act as a harsh critic. List all factual inaccuracies, logical fallacies, and stylistic issues in the following text.'

The loop's primary function is to systematically identify and categorize flaws. Common detection targets include:

• Factual Hallucinations: Statements unsupported by the provided context or knowledge.
• Logical Inconsistencies: Contradictory claims or broken causal chains within the output.
• Format Violations: Deviations from required JSON, XML, or other structured output schemas.
• Safety & Compliance Issues: Content that violates predefined guardrails or policies. This classification directly informs the type of corrective action required.

The critique does not exist in isolation; it acts as the trigger for a subsequent generation or correction step. The identified issues are formatted into a new directive for the primary agent, creating a closed-loop system. This transforms a static output into a dynamic, multi-pass generation process. The loop continues until a convergence criterion (e.g., no new errors found, quality score threshold met) or a cycle limit is reached.

To prevent infinite loops and manage computational cost, self-critique implements halting conditions. These are predefined rules that determine when refinement should stop. Common protocols include:

• Quality Threshold: Stopping when an output scores above 0.95 on a verifiable metric.
• Delta Threshold: Halting when the difference between successive outputs is negligible.
• Fixed Iteration Limit: A pragmatic cap (e.g., 3 cycles) to guarantee termination.
• Error Exhaustion: Stopping when the critique module returns an empty error list.

In production systems, self-critique is rarely the sole validation mechanism. It is typically embedded within a larger output validation framework. The internal critique may be followed by external checks like:

• Schema Validators (e.g., Pydantic, JSON Schema).
• Fact-Checking against a knowledge graph or vector database.
• Code execution for verifying computational outputs. This creates a multi-layered verification and validation pipeline for robust error correction.

Advanced loops employ adaptive correction mechanisms that select different refinement tactics based on the error type. Instead of a full rewrite, the agent may apply:

• Delta-Based Correction: Calculating and applying the minimal edit to fix the specific issue.
• Stepwise Refinement: Decomposing a complex error and fixing it through incremental, verifiable steps.
• Prompt Correction: Dynamically adjusting the initial generation instructions to prevent error recurrence. This adaptability improves efficiency and helps mitigate error propagation across iterations.

This foundational pattern extends standard chain-of-thought reasoning by adding a dedicated verification step. The agent first generates a reasoning trace and a final answer. A separate, often more powerful or differently prompted, critique module then analyzes the trace for logical consistency, mathematical errors, or factual inaccuracies. If flaws are found, the agent regenerates the reasoning. This is common in mathematical problem-solving and code generation tasks, where a single logical misstep invalidates the entire output.

In this advanced architecture, the self-critique is performed by simulating a debate between multiple internal 'personas' or sub-agents. One agent acts as the proposer, generating an initial solution. A second agent acts as the critic, tasked with finding flaws. A third may act as a judge to synthesize the debate into a revised output. This pattern is effective for complex, open-ended tasks like strategic planning, creative writing refinement, or ethical reasoning, where multiple perspectives are valuable.

Here, the critique phase leverages external tools to perform objective validation. After generating an output (e.g., a SQL query, a API call payload, or a summary), the agent programmatically executes the output in a sandboxed environment or uses a validator tool (like a code linter, a fact-checking API, or a unit test) to assess its correctness. The tool's result (pass/fail, error message) becomes the structured feedback for the next iteration. This is critical for agentic tool-calling systems where incorrect tool usage has real consequences.

Popularized by models like Anthropic's Claude, this pattern uses a predefined set of principles or a 'constitution' to guide the critique. The agent generates a response, then a separate critique prompt instructs it to evaluate the response against constitutional principles like helpfulness, harmlessness, and honesty. The agent must rewrite its response to better align with these principles. This is a core technique for alignment tuning and reducing harmful outputs without relying on extensive human feedback.

Instead of complete regeneration, this pattern focuses on generating precise edit instructions. The agent produces an initial draft, critiques it to identify specific shortcomings (e.g., 'paragraph 3 lacks supporting evidence'), and then generates a set of minimal, actionable edits to apply. The system applies these edits programmatically. This is efficient for long-form content generation, document revision, and legal contract analysis, where wholesale regeneration is costly and context loss is undesirable.

This pattern integrates confidence estimation into the loop. After generating and critiquing an output, the agent assigns itself a confidence score. If the score is below a threshold, it triggers another critique-generation cycle. The loop continues until a halting condition is met: either confidence exceeds the threshold, a maximum number of iterations is reached, or successive iterations show no improvement (convergence). This is essential for production systems to manage latency and compute costs while ensuring quality.

A recursive mechanism where an autonomous agent generates an output, evaluates it for errors, and uses that evaluation to produce a revised, improved output. This is the execution phase of the self-critique, turning analysis into action. It's a core component of recursive error correction systems.

• Key Distinction: While a self-critique loop is the analysis phase, the self-correction loop encompasses the full cycle of critique and revision.
• Implementation: Often involves a secondary LLM call or a specialized reasoning module that takes the original output and the critique as input to generate the corrected version.

A two-phase iterative process where an AI agent first generates a critique of its own output and then uses that critique as a directive to generate a new, improved version. This formalizes the feedback loop between evaluation and creation.

• Phase 1 (Critique): The agent acts as an evaluator, assessing its work against criteria like accuracy, completeness, and style.
• Phase 2 (Generation): The agent acts as an editor, using the structured critique to guide a rewrite.
• Application: Fundamental to advanced chain-of-thought and process supervision techniques, where the reasoning process itself is subject to critique.

An iterative process where an agent's output is first passed through a validation or verification step, and any failures trigger a targeted correction routine before re-validation. This introduces an external or formal ground truth check.

• Validation Step: Can use rule-based checkers, code compilers, fact-checking APIs, or consistency verifiers.
• Correction Trigger: Errors are classified (e.g., syntax, logic, factual) to inform the specific correction strategy.
• Use Case: Essential in agentic observability pipelines and for building self-healing software systems that ensure outputs meet functional specifications.

A dedicated phase in an agent's execution where it steps outside its primary generation task to critically examine its output for flaws before finalizing or delivering it. This is a deliberate, structured pause for quality assurance.

• Separation of Concerns: The analysis uses a different "mental mode" or even a separate model instance than the initial generation.
• Focus Areas: Checks for hallucinations, logical consistency, adherence to instructions, and potential safety issues.
• Architectural Role: A key component of agentic cognitive architectures that include explicit reflection modules.

A refinement paradigm where the specific errors detected in an agent's output directly determine the nature and focus of the subsequent corrective generation step. This makes the iteration process targeted and efficient.

• Error Classification: The critique must categorize errors (e.g., "missing data point," "contradiction in paragraph 3").
• Strategic Correction: The next prompt is engineered to address only the identified error classes, avoiding unnecessary full rewrites.
• Connection to Eval: Core to evaluation-driven development, where benchmark performance on error types guides iterative training and prompt design.

The set of rules and metrics that govern when an iterative refinement process should stop. This prevents infinite loops and manages computational cost, ensuring the process is practically deployable.

• Common Halting Conditions:
  • Quality Threshold: Output meets a predefined score (e.g., a confidence score > 0.95).
  • Output Stability: Difference between successive iterations falls below a delta threshold.
  • Cycle Limit: A maximum number of iterations (e.g., cycle-limited refinement).
• Operational Necessity: A critical component for production agentic observability and telemetry, providing deterministic stopping points.