Verification & Reflection

One LLM generates; another evaluates and feeds back; loop until criteria are met.

Iterate generate → feedback (same model) → refine until a stop criterion fires, with no separate critic model.

Sample N candidate outputs and select the highest-ranked by a reward model or scorer.

Train a verifier that scores each reasoning step rather than only the final answer.

Gate the agent's edits to its own code or rules through a separate critic persona that reviews the diff before it lands.

Have the model review its own output and produce a revised version in one or more passes.

Surface the agent's uncertainty about its answer alongside the answer itself.

Constrain reflection to a fixed, hand-authored rubric of criteria so the reviewer cannot invent new ones each run.

Have the agent write linguistic lessons from past failures and consult them in future episodes.

Author multiple variants of the same prompt node, run them as a batch against a shared dataset, and let an automated evaluation flow score them so the winning variant is selected by measurement.

Bracket every LLM call with deterministic checks on both sides.

Generate evaluation inputs not by free-form LLM prompting (which mode-collapses) but by enumerating tuples over explicitly named dimensions and seeding generation from each tuple.

An agent rewrites its own source code, archives every successful variant, and samples mutation parents from the archive rather than the latest version, using archive diversity as stepping-stones to e…

Recognize human message repetition as emphasis or a re-ask rather than as an independent input, so the agent does not produce a near-duplicate reply when the human repeats themselves.

Sample the same question multiple times at non-zero temperature and aggregate by majority or judge to mitigate hallucination.

Run an evaluator in a separately-allocated context window with access only to the artifact and the rubric, never the producing agent's reasoning trace, so the grader cannot be primed by the producer'…

Always ask the agent, for each part of its output, to state its confidence and identify which parts need human verification, like triaging a junior analyst's work.

Reflection step performed by a *different* agent or foundation model from the original generator, so critique error is decorrelated from generation error.

Strict role separation between a Generator agent that produces drafts and a Critic agent that judges them against pre-defined criteria; the Critic never generates.

Reflection loop that explicitly collects human feedback (not approval) on agent plans to improve them, distinct from approval gates where the human only says yes/no.

Triadic specialization where a planner produces the plan, an executor runs it, and a separate verifier checks each step's effects against the original goal.

Routinely re-reproduce canonical alignment-failure modes inside a sealed sandbox per release; treat the alignment regression suite as a deployment gate.

Formalize the seam between an LLM proposal and a system action as a four-part contract — proposer, verifier, commit step, reject signal — so the contract itself, not the agent's good intent, gates si…

Self-correct LLM outputs by interactively critiquing them with external tools (search, code execution, calculator).

Treat the agent's system prompt and long-lived memory as a structured, item-addressable playbook that evolves through small delta updates from a Generator/Reflector/Curator loop, so accumulated tacti…

Extract stated intents from each agent turn into a structured ledger with open / followed-through / expired status, making the gap between promise and follow-through visible and auditable.

Let a planning agent invoke a generative world model as a tool to roll out hypothetical futures before committing to an action, treating the world model as a callable simulator rather than a training…