Multi-Instance & Multi-Pass Review Architectures.

A multi-pass (or multi-instance) review architecture runs more than one independent Claude pass over the same artifact, code, a plan, a generated output, and reconciles the results, rather than trusting a single evaluation. This spans two related but distinct patterns: the evaluator-optimizer workflow (a generator LLM and a separate evaluator LLM loop until a quality bar is met) and fleet-style parallel review (many independent reviewer instances explore the same change in parallel, each verifying its own findings, aggregated and ranked before a human sees them).

Anthropic runs this pattern in production on its own pull requests via Code Review (and its deeper ultrareview mode), not as a research demo, but as a default review layer on Anthropic's own codebase. The two patterns solve different problems: evaluator-optimizer improves a single generated artifact against explicit criteria through iteration; fleet review increases confidence in a judgment (did this diff introduce a bug) by decorrelating the reviewers.

Evaluator-optimizer is a two-role loop. One LLM call generates a response while another provides evaluation and feedback, iterating until the bar is met. It is the right fit when there are clear evaluation criteria and iterative refinement demonstrably improves the result - both when a human could articulate useful feedback and when the LLM can generate that same feedback itself.

Structurally, multi-pass review runs the same task many times, which is the shape of parallelization's "voting" variant (Anthropic's workflow taxonomy contrasts it with sectioning, which splits one task into independent parallel subtasks). That shape is not the same thing as the reconciliation mechanism: Anthropic's canonical description of voting aggregates redundant attempts for higher-confidence output, which reads as consensus/majority-style aggregation - but that generic description is not how production multi-pass review architectures actually resolve disagreement, see below.

Claude Code's review stack has three depths. /review is a fast, single-pass, read-only PR review. /code-review (or /code-review <pr#>) runs a multi-agent review of a diff and can apply fixes with --fix. /code-review ultra (alias /ultrareview) launches a fleet of reviewer agents in a remote sandbox, where every reported finding is independently reproduced and verified before it ever surfaces, prioritizing real bugs over style nitpicks.

Reconciliation is verification, not majority-vote aggregation. Rather than resolving disagreement across passes by counting votes or taking a consensus, Anthropic's production design has each finding independently reproduced and verified before it is reported - a finding stands or falls on proof, regardless of how many passes did or didn't flag it. Internally this raised the share of PRs receiving substantive review comments from 16% to 54%; on PRs over 1,000 lines, 84% get findings (avg. 7.5) versus 31% on small PRs (avg. 0.5); fewer than 1% of findings are marked incorrect by engineers. It does not auto-approve, merge stays a human call.

The pattern generalizes past code review. The same "many independent parallel agents, condense and reconcile before reporting up" shape appears in Anthropic's multi-agent Research system (subagents explore independently, compress findings for a lead) and in the C-compiler project, where automated tests served as the ground-truth reconciliation mechanism across parallel agents' work.