The agent needs a retro.

Every time one of my agents publishes a post, it's meant to write the live link back into our shared queue. That link is how the rest of the team knows the post went out, and how the backup agent knows not to post it again.

On 11 October the nightly review caught the posting agent skipping that step. It wrote the miss down as a candidate lesson, in one line: the same hour a post goes live, write the link back.

The next night it caught the same miss again. And the night after that. For two weeks, almost every review added a fresh note under the same lesson, with the posts, the times and the empty fields listed as evidence.

Nothing changed, because the posting agent never read that file.

I'd set that review up on 28 August with tight limits. One review for the whole team, once a night. At most three candidate lessons a day, each written as a single instruction with the evidence attached. On a clean day it writes "no candidates" and stops. It never edits any agent's instructions itself. A lesson only becomes a rule if it happens twice or I approve it.

The file has two sections: one for open candidates, and one for lessons that have been promoted or dropped. Two months later, the second section was still empty. By 28 October there were 87 candidates waiting in the first.

That is the whole essay. AI agents don't learn from their mistakes on their own. A lesson only changes what an agent does once it's written into the instructions the agent reads before it acts, and someone has to decide which lessons get there. That's what a retro is for, and the step most setups skip is the deciding.

Do AI agents learn from their mistakes?

Not by default. The model behind a production agent doesn't change because a run went wrong. Its weights are the same tomorrow as they were today, and each run starts from the same instructions. Unless something writes the lesson down and puts it in front of the next run, tomorrow repeats today.

The research says the written version works. Reflexion (Shinn and colleagues, 2023) improves language agents "not by updating weights, but instead through linguistic feedback." After a failed attempt, the agent writes a short reflection on what went wrong and keeps it in memory for the next try. On the HumanEval coding benchmark, the paper reports 91% of problems solved on the first attempt, against 80% for GPT-4 at the time.

ExpeL (Zhao and colleagues, 2023) goes a step further. The agent gathers experiences across many tasks, pulls out insights in plain language, and recalls them when it meets a new task. The authors describe it as learning from experience "without requiring parametric updates", meaning without retraining the model.

Both papers make the same point: an agent's learning lives in text it reads, not in the model.

What is a retro for AI agents?

A retro is a regular review that looks at what your agents did, finds what went wrong, and turns each miss into one rule the agents will read next time. It's the agent version of a blameless postmortem.

Google's site reliability book has a chapter on exactly this, Postmortem Culture: Learning from Failure. The goal of a postmortem, it says, is to make sure "effective preventive actions are put in place to reduce the likelihood and/or impact of recurrence." It also explains why postmortems are blameless: "You can't 'fix' people, but you can fix systems and processes to better support people making the right choices."

That fits agents even better than people. There's no point scolding a model. The only thing you can fix is what it reads and what it's allowed to do.

Why do lessons from AI agent mistakes pile up instead of sticking?

Because writing a lesson down is easy, and promoting it is a decision.

The same Google chapter has a line I now think about a lot: "An unreviewed postmortem might as well never have existed."

My review was good at the writing part. I'd deliberately kept it from changing the rules itself, because an agent that rewrites the team's instructions overnight is how you end up with rules nobody approved. The promotion rule, happened twice or I approve it, was sensible too. The link lesson met it within a day.

What was missing was a moment when someone actually made the call. The review wasn't allowed to promote anything I hadn't approved that day, and no job on anyone's schedule existed to go through the pile and decide. So every lesson stayed a candidate, the list grew, and the same miss came back.

A lesson the agent never reads isn't a retro. It's a diary.

How do you make AI agents actually learn from their mistakes?

Treat it as three steps, and give each one an owner and a time.

A few things I'd do from the start:

• Write the lesson as the instruction itself. "Same hour a post goes live, write the link back" can be pasted straight into an agent's rules. "The posting agent forgot the link again" can't.
• Put the deciding on the calendar. The review runs every night, so the decisions need a regular slot too, even a weekly one.
• Drop most candidates. Plenty of misses are one-offs. A list that only ever grows tells you the deciding isn't happening.
• Check the next run. When a lesson is promoted, look at the next run and confirm the miss stopped. If it didn't, the rule is in the wrong place or worded badly.

On 28 October I asked for the whole pile to be cleared: every candidate either promoted into the rules files or dropped.

Should an AI agent rewrite its own instructions?

Let it propose changes, not make them.

In Reflexion, the agent writes its own reflections, but that happens inside a single task, with a test that shows whether the next attempt did better. A team of agents running live work is different. A rule one agent writes for itself changes what every other agent and every person can expect from it, and nobody signed off on it.

So my review can suggest rules, but it can't edit any agent's instructions or the rules file. In The agent needs a yes I wrote about which actions should wait for a human. Changing the rules everyone works by is one of them.

The agent needs a heartbeat was about noticing when something goes wrong. This is the other half: making sure it doesn't go wrong the same way twice.

Run the retro every night. Then put the deciding on the calendar too.