Reflexions- und Selbstkorrekturschleifen für Agents

Reflection is an agent pattern where the model reviews its own output, identifies flaws, and produces an improved version — without a human in the loop.

It turns a one-shot answer into an iterative draft-then-revise process.

Two roles drive reflection:

• Generator: produces a candidate answer
• Critic: evaluates it against criteria and suggests fixes

They can be the same model with different prompts.

Generate, critique, then regenerate using the critique. Repeat until the critic is satisfied or a limit is hit.

A good critic is specific. Give it explicit checklist criteria so feedback is actionable rather than vague praise.

The Reflexion technique stores past mistakes as text memory. The agent reads its prior reflections before the next attempt, so it does not repeat errors.

Reflection is far stronger when the critic can run tests, compile code, or query data — replacing opinion with evidence.

Unbounded reflection can loop forever or burn tokens. Always cap iterations and add an early exit when the critic approves.

Quality usually plateaus after 2-3 cycles. Track whether each revision actually improves a measurable score; stop reflecting once gains stall.

Each reflection cycle is extra LLM calls. Reserve reflection for high-value or error-prone tasks (code, planning) and skip it for simple ones.

A model can confidently approve its own wrong answer. Use a different model or external tools as the critic when correctness is critical.

In a larger agent, reflection sits after each major step: act, observe, reflect, adjust the plan. This makes long autonomous workflows far more robust.

You learned the reflection pattern: a generator-critic loop where the agent critiques and revises its own work. Use specific critic criteria, ground critiques in tools, store reflections as memory, bound iterations, and use an independent critic for high-stakes correctness.