ReasoningBank: Why Your AI Agent Should Learn From Its Mistakes

I’ve been watching the agent space for a while now, and there’s a persistent problem that keeps bugging me: agents are terrible at learning from experience. They’ll make the same dumb mistake across a hundred tasks, and nobody seems to care. Google’s ReasoningBank paper, presented at ICLR this year, finally takes a real swing at this.

The core idea is refreshingly simple. Instead of saving every single click and keystroke like Synapse does, or only recording the winning workflows like Agent Workflow Memory, ReasoningBank distills both successes and failures into high-level reasoning patterns. Think of it as the difference between memorizing the exact moves of a chess game versus understanding the strategic principle behind those moves.

Here’s the part that got my attention: the framework actively seeks out failures. Most memory systems are success-obsessed. They capture the golden path and discard everything else. But in real-world deployments, failures are where the real learning happens. ReasoningBank turns those failures into “preventative lessons” — strategic guardrails that stop the agent from walking into the same trap twice.

Take web navigation as an example. A naive agent might learn to click a ‘Load More’ button. But an agent using ReasoningBank, after failing to a infinite scroll trap, learns to “always verify the current page identifier before attempting to load more results.” That’s the difference between a rote procedure and genuine tactical foresight.

The workflow runs in a closed loop. Before acting, the agent retrieves relevant memories from the bank. After each trajectory, an LLM-as-a-judge evaluates the outcome — success or failure — and extracts insights. The authors note the self-judgment doesn’t need to be perfect; the system is robust to noise. New memories get appended directly to the bank, which is pragmatic for now, though I’d expect more sophisticated consolidation strategies in future iterations.

I appreciate that they didn’t over-engineer the memory format. Each item has a title, description, and content — the distilled reasoning steps or decision rationales. No bloated schemas, no unnecessary complexity. It’s clean enough to be useful without being a pain to implement.

On the benchmarks, ReasoningBank showed improvements in both success rates and efficiency — fewer steps to complete tasks. That efficiency gain is a big deal for anyone running agents at scale. Every wasted action adds up.

There’s a deeper point here that the paper doesn’t hammer on, but I’ll say it: this approach shifts agent design from “write perfect prompts” to “let the agent learn from its own mess.” That’s a more realistic path to robust behavior in the wild. We can’t anticipate every edge case at design time, but we can give agents the tools to adapt.

If you’re building agents that run for more than a few minutes, ReasoningBank is worth a look. The code is on GitHub, and the paper is open. It’s not a silver bullet, but it’s a solid step toward agents that actually get better over time — instead of just repeating their mistakes forever.