When does feedback actually improve an LLM agent?

Thirteen open-weight models acting as both student and teacher, four different benchmarks (Omni-MATH, Codeforces, BBEH Linguini and ARC-AGI1) and an uncomfortable question: when an LLM agent improves after receiving feedback, does it improve because the feedback helped, or simply because it got another attempt? A new paper published on arXiv argues that, in many cases, it is the latter.

The paper What Drives Interactive Improvement from Feedback? starts from a methodological problem that affects almost any multi-turn agentic system. When we measure the final accuracy of an agent that revises its answers turn by turn, that number blends several effects: useful feedback, yes, but also resampling (rolling the dice again), format correction and extra test-time compute. Pushing the final number up does not prove the model understood anything it was told.

What they measured and how

To isolate the effect of feedback, the authors set up a controlled student-teacher protocol. They compare three conditions: external feedback (another model plays teacher), self-feedback (the model critiques itself) and unguided self-refinement (the model retries with no comment at all). On top of that, they vary the interaction history, task difficulty and whether the teacher has access to privileged information about the problem, for example the correct solution.

The key comparison is against unguided self-refinement. That is the honest bar: if letting the model retry without any comment already raises accuracy, then any gain below that threshold is not credit due to the feedback.

The finding

The results are unflattering for self-generated feedback. Self-feedback adds almost nothing over blind retrying. That is, asking a model to critique itself and then retry performs nearly the same as letting it retry without saying anything. Only the strongest external teachers produce feedback-specific gains that are substantial, and they do so because they offer guidance that goes beyond a generic "try again".

There is an interesting nuance in the dense student-teacher interaction matrices the authors build. Interactive gains depend more on the student's ability to use the feedback than on the raw power of the teacher. Put another way: good advice poorly used is worthless, and some models are structurally better listeners than others.

Why it matters

For anyone building agents, the implication is direct. Many current pipelines chain "generate, self-critique, fix" loops and present the resulting improvement as proof that the reflection loop works. This work suggests that much of that improvement could come from the mere act of retrying, not from the reflection itself. Before adding self-critique layers to a system, it is worth measuring against the honest baseline: how much does the model improve if we let it retry without telling it anything?

The second lesson points to evaluators. If we use an LLM as a judge or as a teacher inside an improvement loop, its real value depends on it providing information the student did not have and, on top of that, on the student knowing how to use it. A teacher with access to privileged information makes a difference; one that repeats obvious things does not.

It is worth reading the study with context on what it measures and what it does not. It works with thirteen open-weight models and four specific benchmarks, not with closed commercial models or real production tasks, so extrapolating to a deployed agent running Claude Code or similar calls for caution. Even so, the experimental framework is clean and the question it raises is the right one.

At ClaudeWave we have long been wary of self-reflection loops sold as a cure-all, and this paper puts numbers to that intuition: feedback only helps when it says something the model did not know and the model knows how to listen. It is not a spectacular result, but it is the kind that saves compute and disappointment for anyone designing agents.