Run retrospectives for your agents, not just your team
Teams run retros to improve how humans work, but agent mistakes die with the session. Saving sessions, letting a retro agent mine them and turning failures into config rules makes the learning compound.
Written by
-
Benedikt Stemmildt Founder & Co-CEO
Published: 15 January 2026 Updated: 2 min read
Your team does retrospectives. Your agents don’t. That’s why your agents keep making the same mistakes.
Agent learning dies with the session
Teams run retros to improve how humans work. But hardly any team runs retros for its agents.
Every bug your agent creates, every edge case it misses, every pattern it gets wrong: that knowledge dies when the session ends. Next sprint, same mistakes, different ticket.
The anti-patterns look like this:
- No memory: the agent learns nothing between sessions.
- No compounding: the same fixes get applied by hand, every time.
- No team knowledge: one developer’s agent insights stay siloed.
- No iteration: system prompts get written once and never improved.
- Groundhog Day: the agent repeats the same architectural mistakes.
The fix is to run retros for your agents the same way you run them for humans. Four steps.
1. Preserve session episodes
Save your agent session logs as discrete episodes:
- The full conversation transcript
- What worked and what didn’t
- Where you had to correct the agent
- Context it was missing
Each session is a chance to learn. Most teams throw them away.
How to start: export session logs after significant coding tasks and store them in a shared location.
2. Run a retro agent
Let an agent analyze the episodes for:
- Patterns across sessions
- Recurring failure modes
- Missing context that caused errors
- Successful prompts worth reusing
The retro agent reads what your coding agents struggled with and extracts the learnings.
3. Update agent configurations
Convert failures into rules:
- “Agent kept using deprecated API” becomes the config line “Always use v2 API. v1 is deprecated.”
- “Agent created components in wrong directory” becomes the config line “New components go in src/components/features/”
One bug, one rule, fixed for good. This works for any agent harness: Claude Code, Cursor, Copilot, Codex, custom setups.
4. Compound across the team
These learnings live in your codebase. Every developer gets them automatically, and a new hire’s agent is as well-armed as a senior’s. Your agent configuration becomes institutional knowledge that compounds.
Two kinds of retro, one effect
Human retros produce better human processes. Agent retros produce better agent configurations. Both compound, and both make the next sprint better than the last.
We started with minimal agent context. After 3 months of agent retros, our configuration files are 400+ lines of hard-won knowledge. Every line is a mistake we’ll never make again. That’s compounding.
Are you improving your agents sprint over sprint, or starting from zero every time?
Further reading
Written by
-
Benedikt Stemmildt · Founder & Co-CEO
More on Software Factory
- Compounding engineering makes each feature ease the next one Most teams use AI to code faster. Compounding engineering adds a fourth step, codify, so that every feature makes the next one easier to build.
- Agent-paced merging turns the merge queue into a database problem The merge queue used to be a scheduling problem between people. With agents opening changes around the clock, it becomes concurrency and conflict resolution against shared state.
- Six developer experience investments that outlast the next model Most agentic tooling bought this year will not survive the next model generation. Six fundamentals will, because what is good for human developers turns out to be good for agents.
Scaling needs named owners
Coding agents scale across teams when named people own the platform, the team practice, the guardrails, and the measurement. Rollout & scale is where that ownership is built and handed to internal owners, in your stack.
Training on this topic: Agentic Software Factory: Advanced Team TrainingWant to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check