Agents and the Critique Loop: When to Self-Review

The critique loop in one sentence

The agent’s job is to surface the work; the agent’s secondary job is to self-review the work before surfacing. The operator (or a separate steelman judge agent) is the final reviewer.

Three layers:

1. Self-review at the agent level. The agent runs a 4-question check on the work before saying “ready.”
2. Steelman judge at the swarm level. A separate agent reviews the work and either approves or pushes back with a critique.
3. Operator at the operator level. The operator reviews the surfaced work and either ships, edits, or sends back.

Each layer catches different classes of bug. None of them is optional for non-trivial work.

The 4-question self-check

Run these before any bulk action or quality check:

1. Is the work aligned with the operator’s instruction? If the operator asked for a draft, did I draft? If they asked for analysis, did I analyze? Misalignment here is the most common failure.
2. Is the work accurate? Are the facts right? Are the code paths real? Are the commands actually valid?
3. Is the work within the rule boundary? Did I cross the system-prompt boundary? Did I break a no-bulk-surprises rule? Did I add memory without going through Johnny5?
4. Is the work shippable? Does the build pass? Does the dist match? Do the regression tests pass?

If any of these is “no,” the agent surfaces the issue rather than the work.

When self-review is enough

Self-review is enough when:

• The work is small (one edit, one command, one verified fact).
• The blast radius is contained (no deploy, no system change, no irreversible action).
• The operator has a clear answer pending (“is X set?”).
• The cost of a wrong answer is low (the next message can correct).

For self-review-sufficient work, the agent surfaces without a separate critique pass. The 4-question check is the only gate.

When to defer to a steelman judge

Defer to a separate steelman judge when:

• The work is non-trivial (a deploy, a multi-file edit, a long document, a model choice).
• The work has multiple valid answers and the choice isn’t obvious.
• The operator specifically asked for a critique cycle.
• The cost of a wrong answer is high (visible external consequence).

The steelman judge agent is a separate Hermes session with: (a) access to the original work, (b) a system prompt demanding steelman-positive critique, (c) a fixed output structure (Approve / Approve with reservations / Reject with critique). The judge does NOT redo the work — it reviews what’s been surfaced.

When to defer to the operator only

The operator-only path is for:

• Irreversible actions (force-push, deletes, schema changes).
• Decisions that change scope (ship N guides vs. ship N-3).
• Anything the operator explicitly wants to approve first.

The agent surfaces a clear question and waits. No self-review, no steelman judge — the operator is the only acceptable gate.

Multi-agent swarm pattern

The operator’s preferred pattern on a hard problem:

1. Spawn 3-4 sub-agents across providers (GPT + Gemini + MiniMax + Anthropic).
2. Each sub-agent drafts the work independently.
3. Spawn a steelman judge agent (different model).
4. Judge reviews each draft against the operator's instruction.
5. Pick the draft that best satisfies the criterion.
6. Operator has final approval.

The point isn’t that the swarm produces the best draft every time. The point is that the critique loop catches the failure modes that single-agent work misses. Three providers’ blind spots cancel out.

What self-review is NOT

• Self-review is not “ask the model if it’s right.” The model’s self-assessment is the worst signal. Run the 4-question check against the work, not against the model’s confidence.
• Self-review is not “ignore the user’s red flags.” If the operator questioned something, surface that question even after self-review passes.
• Self-review is not “delay the surfacing.” Self-review should add minutes, not hours. If it’s taking too long, escalate to steelman judge.

The signal that self-review is passing too easily

Two patterns mean the 4-question check is sliding:

1. Every question gets a yes. If your self-checklist produces all “yes,” the agent is rubber-stamping — the questions are too easy or the work is too small to deserve the formal check. Either tighten the questions (ask “what did I miss?”) or downsize the gate.
2. The agent skips the check entirely. If a work-cycle produced ship-ready output without running the check, the gate wasn’t actually wired — it’s a ceremonial mention in the prompt. Re-run with the check inline.

Self-review that always passes is the same as no self-review; the value is in the misses.

What not to do

• Don’t ship without the 4-question check on non-trivial work.
• Don’t run a steelman judge on small edits.
• Don’t bring the operator in for low-stakes decisions the agent can answer.
• Don’t trust the model’s “yes, that’s correct” self-assessment.

Verification checklist

#	Question	Action
1	Did I run the 4-question check on this work?	Yes/No
2	Is the blast radius visible to the operator?	Yes/No
3	Would a steelman judge catch something I missed?	If yes, run one
4	Is the operator’s tolerance for an irreversible step?	High-blast: surface twice

Sources

• Hermes Agent multi-agent swarm docs
• ABS companion: Agents and Their Rules of Engagement: No Bulk Surprises
• ABS companion: Hermes Protocol: The System Prompt, the Context Window, and the Rule Boundary

Last verified: 2026-07-14 against Hermes v0.18.2 (2026.7.7.2).