Learn
Learning is the quick, local part of self-improvement. It looks at one run, or a few you pick, soon after they finish, and keeps what the next run would otherwise have to work out again.
It does three things:
- Reflect on the run to find the moments that mattered.
- Generate memories from what the run established.
- Generate a skill when the run followed a procedure worth repeating.
Learning doesn't change the agent. It adds to the context agents read. To change the agent itself, see Heal.
Reflect
Reflection reads the run's trace and looks for:
- Corrections. A person told the agent it was wrong, or pointed it somewhere else. "Ignore the database, check the deploy."
- Turning points. The step where the investigation changed direction, and what evidence caused it.
- Hard-won facts. Something the agent spent many tool calls finding that won't change soon, such as which cluster a service runs on, or which dashboard has the real error rate.
- Failures and their fixes. A tool call that failed, and what worked instead.
- Procedures that worked. A sequence of steps that reached the answer and would work again on a similar problem.
Each finding cites the messages it rests on, so a reviewer can open the run and check it.
Generate memories
A memory records one fact or lesson, and when it applies:
title: Check the deploy before the database on payment timeouts
applies_when: Payment timeouts start within minutes of a payments deploy
guidance: >-
Compare error rates before and after the deploy first. In the 2026-10-09
incident the connection pool only looked exhausted because of a monitoring glitch.
avoid_when: The timeouts started more than an hour after the last deploy
Before proposing a memory, reflection reads the memories that already exist. It can propose a new memory, a replacement for an outdated one, or archiving one the run proved wrong. It proposes nothing when the run taught nothing new. A routine run usually produces no memories, and that's expected.
When it runs
- For agents you write in
agent.yaml, once memory generation is turned on for the agent: after each successful turn, once the conversation has been quiet for 5 minutes. A quick back-and-forth with a person produces one reflection, not one per message. - For investigations, when the investigation finishes with a hypothesis at 75% confidence or higher, when a person accepts a hypothesis, or when the incident is resolved. A person's acceptance outranks an automatic reflection: if the agent reflected on its own first, accepting the hypothesis runs it again with the stronger signal.
New memories go to the review queue on the Memories page, under that page's auto-accept rules.
Generate a skill
Pick one or more runs and ask Autoheal to write a skill from them. The skill describes the procedure the runs followed: which data to check first, how to tell the likely causes apart, and when to stop.
For example, from three investigations of payment timeouts after a deploy:
# Payment timeouts after a deploy
1. Compare the payments error rate in the 15 minutes before and after the deploy.
2. If it jumped within a minute of the deploy, confirm in the logs that the new
errors come from the deployed version.
3. Ask for approval, then roll back to the previous version.
4. Check error rates again 5 minutes after the rollback.
More runs make a better skill. With one run, the skill copies that run's details. With several, it keeps the steps they had in common.
The skill is opened as a pull request against your skills folder. See Skills for where skills live and how agents use them.
Memory or skill?
If a memory is the coordinates of the destination, a skill is the directions to get there from wherever you start.
| Keep it as | When the run | Example |
|---|---|---|
| A memory | Found a fact or reached an outcome that's specific to one system | "The payments service's timeouts are set in config/payments.yaml, not in the Helm chart." |
| A skill | Followed steps that would work again on a different but similar problem | "How to check whether a deploy caused an error spike" |
A trajectory that's very specific to one incident makes a poor skill: the next run won't follow the same path, and it pays the tokens to read the skill every time. Store what the run found as a memory instead.
Automatic skill curation
Coming soon. Automatic skill curation is not available yet.
Generating a skill from runs you pick comes first. After that, Autoheal will also notice when several runs have followed the same procedure, and propose a skill on its own. It will also propose updates to a skill when runs that used it kept departing from it the same way.
Learning from artifact feedback
Today learning starts when a run succeeds. A thumbs-up or thumbs-down on an artifact, such as a postmortem, will also start it. A thumbs-down tells reflection what the run got wrong.
Limits
- A run that went wrong can teach the wrong lesson. A reviewer should check that each memory is backed by the cited messages, not just by what the agent believed at the time.
- Learning sees only the runs it's given. A pattern that shows up only across many runs is a job for Heal.
Related
- Memories: the review queue and auto-accept rules
- Skills: where skills live and how agents load them
- Heal: changes to the agent itself, across many runs
- Capabilities: which agents can read and write memories and skills