ralph-wiggum-loop

The Ralph Wiggum loop — agent self-review pattern named after the Simpsons character: keep iterating with enthusiastic dedication until every reviewer signs off. The name and the pattern come from Geoff Huntley’s The Ralph Wiggum Loop (ghuntley.com/loop), cited directly by 2026-04-27-harness-engineering-codex-agent-first as the shape the OpenAI codex team uses to drive PRs to completion without a human in the loop.

The pattern, as deployed at OpenAI Codex

From 2026-04-27-harness-engineering-codex-agent-first: humans interact almost entirely by prompting — the engineer describes a task, runs the agent, and lets it open a PR. To drive that PR to a state where it can merge, codex is instructed to:

1. Self-review locally. Inspect its own changes against the codebase’s standards.
2. Request additional reviews from other agents (locally and in the cloud).
3. Respond to all feedback — human or agent — with code or argument.
4. Loop until every reviewer (agent or human) is satisfied.

codex uses the standard developer toolchain directly (gh, local scripts, repo-embedded skills) to gather context for each iteration; no human copy/paste of context is required. Most PRs no longer need a human reviewer at all; the human review slot has become an opt-in, not a requirement.

Why it works

Three properties of the codebase make the loop safe to leave running:

• Strong invariants mechanically enforced. A reviewer agent that flags a layering violation isn’t expressing taste — it’s surfacing a deterministic rule. The author can act on it without judgment.
• Repo as system of record. Every reviewer agent reads from the same source of truth; disagreements have a fixed ground.
• Verifier-driven acceptance. The lint-and-test result is the final arbiter; the loop terminates when the verifiers pass and the reviewers stop objecting.

Without these, the same loop could oscillate forever between contradicting agents or converge on a wrong answer (compare the hallucination amplification failure mode on multi-agent-orchestration).

Distinct from a generic Agent Loop

The vanilla Agent loop is perceive → decide → act → feedback, run until the model emits plain text. The Ralph Wiggum loop is a specific control pattern layered on top: the feedback comes from other agents reviewing the work, and the termination condition is all reviewers + verifiers happy, not “the model decided to stop.”

In agent-loop‘s “five common control patterns” table, this is closest to Evaluator-Optimizer — but with the evaluator multiplexed across several agents rather than a single critic, and with verifier output (lint, tests, structural checks) sharing the evaluator role.

When it earns its complexity

The pattern is overkill for low-stakes, low-throughput work. It earns its place when:

• Throughput is high enough that waiting for a human reviewer becomes the bottleneck (the OpenAI Codex team reports ~3.5 PRs / engineer / day; see codex).
• Verifier output is mechanical and trustworthy — a Ralph Wiggum loop iterating against a flaky verifier just amplifies noise.
• Reviewer agents have independent prompts or context — otherwise they collapse to one voice and the loop is single-reviewer-with-extra-steps.

The post is explicit: this depends on the codebase’s specific structure and tooling, and shouldn’t be assumed to generalize without similar investment.

Vendor corroboration of the core insight

anthropic‘s loop-engineering post (2026-07-12-loop-engineering-getting-started) independently lands on the pattern’s load-bearing premise: “a reviewer with fresh context is less biased and not influenced by the main agent’s reasoning” — and ships it as the built-in /code-review skill and Code Review for GitHub. That’s the single-reviewer slice; the full Ralph Wiggum shape (loop until every reviewer + verifier is satisfied) remains the codex-side deployment. The post’s proactive-loop diagram gets close: main agent loops until the verification skill passes → opens a PR → a second agent reviews → the human only decides what to merge (loop-engineering).

Relation to other concepts

• agent-loop: the underlying loop shape. Ralph Wiggum is one named instantiation.
• multi-agent-orchestration: review-by-multiple-agents is the multi-agent mechanism this pattern depends on. The “independent verification” rule from that page is what keeps the loop from amplifying hallucinations.
• verifier-loop: the closing layer the loop terminates against.
• codex: the agent currently running this loop in the post’s primary case study.

External reference

Geoff Huntley, The Ralph Wiggum Loop (ghuntley.com/loop) — the original framing the OpenAI post cites. Worth ingesting as its own source if it’s later dropped into raw/.