What is the Reflexion mechanism and how does it avoid fine-tuning?

**Reflexion** is a way to make an agent get better at a task across repeated attempts without ever retraining the model. The model weights stay completely frozen. The trick is feedback in words instead of feedback in gradients. After the agent finishes a trial and the result is judged a failure, a second step asks the model to look back and write a short critique. The critique says, in plain language, what went wrong and what to try differently. That critique is saved in a small memory buffer that survives across trials. When the agent starts the next attempt, the stored critiques are pasted into the prompt. So the agent reads its own past lessons before it acts again. Because the only thing that changes between trials is the text in the prompt, no gradient update happens. The improvement lives in the memory, not in the network. This makes Reflexion cheap and fast compared to fine-tuning on failures.

**Reflexion** lets an agent improve across attempts using verbal reinforcement instead of gradient updates. The model weights never change. The learning signal is natural language text held in memory. The loop has three roles. An actor attempts the task and produces a trajectory. An evaluator scores that trajectory as success or failure, using a test, a reward signal, or a heuristic. A self-reflection step then reads the failed trajectory and writes a short critique explaining what went wrong. That critique is appended to an episodic memory buffer. On the next trial, the stored reflections are prepended to the actor's prompt as extra context. The agent therefore conditions its next attempt on its own past mistakes, which is why later trials avoid earlier errors. This is in-context learning, not weight learning. Reflexion is much cheaper than fine-tuning and needs no labelled gradient data. The cost is that memory only persists while it fits in the context window, so reflections must stay concise and the buffer must be pruned over long runs.