TL;DR: A self-improving AI agent is an AI system that learns from the results of its own work and changes how it handles future tasks. It sets a goal, takes action, checks the outcome, and keeps the changes that make its results better. Some agents improve by remembering lessons, some by testing strategies against each other, and some by rewriting their own code or retraining their model. The hard part is proving that a change helped, which is why every self-improving agent needs reliable tests.
I spend a lot of time speaking with agent teams, and we hear that most AI agents make the same mistakes repetitively. The agent misses a flag on Friday that it missed on Monday. Someone reads the traces, updates a prompt, and hopes nothing else breaks. A self-improving agent takes over part of that work. It notices what went wrong, tries a fix, tests it, and keeps the fix only if results improve. This guide explains how that works in plain terms, what self-improving agents can and cannot do, and the differences between other improvement methods.
What is a self-improving agent?
A self-improving AI agent is an AI system that can learn from its results, identify its mistakes, and improve how it performs tasks over time. The improvement carries forward: the next task starts from a better version of the agent.
Think of it like a new employee. On the first day they follow the handbook. By the third month they know which customers need extra detail, which shortcuts cause problems, and which checks save time. A self-improving agent builds up that kind of experience, then uses it.
One distinction keeps the term useful. Some AI systems improve a single answer: they write a draft, critique it, and revise it before you see it. That is self-correction, and it helps, but nothing carries over to the next task. A self-improving agent changes its future behavior across many tasks.
In short, a normal AI agent does a job. A self-improving AI agent does a job, learns from the outcome, and does the job better next time.
How does a self-improving agent work?
Every self-improving agent runs some version of the same four-step loop:
- Set a goal. The agent receives a task, such as answering customer questions accurately.
- Take action. It tries to complete the task with the tools and information it has.
- Evaluate the result. It checks what worked, what failed, and what could be better.
- Improve and try again. It updates its approach, stores useful lessons, or changes its own code when it is allowed to.
The cycle looks like this: Goal → Action → Feedback → Improvement → Better results.
The first two steps come from earlier research on how agents act. ReAct, published at ICLR 2023, showed language models alternating between reasoning about a task and taking actions such as searching a knowledge base, then using what they observed to decide the next step. Self-improving agents add the last two steps: they judge the outcome and keep what they learned.
What can an agent change about itself?
An agent can change four things: its instructions, its memory, its tools and workflows, or its model weights. These sit side by side as options, and one system can combine several. Each counts only when the change persists and wins on evaluation.
- Instructions and prompts. The cheapest change to make and the easiest to roll back. A prompt edit is a candidate change, and it becomes evidence of improvement only after it beats the old prompt.
- Memory, experience, and skills. Reflexion stores written reflections that carry into later attempts and reports 91% pass@1 on HumanEval. Voyager builds a growing library of executable skills in Minecraft.
- Tools, code, and workflows. Sakana's Darwin Gödel Machine (DGM) rewrote its own agent code. It discovered a patch validation step, better file viewing, enhanced editing tools, and a way to generate and rank multiple solutions, and it improved from 20.0% to 50.0% on SWE-bench. The foundation model was never retrained, and an agent optimized with Claude 3.5 Sonnet also improved when powered by o3-mini or Claude 3.7 Sonnet.
- Model weights. STaR generates reasoning, keeps the rationales that reach correct answers, and fine-tunes on them, round after round. Model training with reinforcement learning on scored attempts is another route.
How is a self-improving agent different from fine-tuning, recursive self-improvement, or agentic ML?
The key distinction is what changes: fine-tuning changes a model's learned parameters; recursive self-improvement changes the system that performs subsequent improvement; agentic ML automates ML development work. These describe different layers of a system, not four mutually exclusive approaches.
Self-improvement vs fine-tuning
Fine-tuning changes a model; self-improvement describes a broader feedback loop that helps an AI system get better. Fine-tuning updates a pretrained model’s weights using additional training data to improve specific behaviors or tasks. Self-improvement uses feedback to evaluate results and refine the system, potentially changing its prompts, tools, memory, or workflows without changing the underlying model.
The two aren’t mutually exclusive: a self-improving system can use fine-tuning as one mechanism for turning experience into better performance.
Self-improvement vs recursive self-improvement
Self-improvement raises task performance through retained, validated changes. Recursive self-improvement is the stronger claim: the agent also improves the mechanisms that generate or evaluate later improvements. DGM asks this question directly, testing whether self-modification can speed up further improvement, and it runs under sandboxing and human supervision. Human oversight and deployment gates are separate design decisions from either definition.
Self-improvement vs agentic machine learning
Agentic ML automates ML development work. Our agentic machine learning article covers agents that do model-development work, such as an ML autoresearch agent. This article covers changes to the agent system itself. The two overlap when an agent improves its own underlying model.
When does fine-tuning an open-weight model make sense?
An open-weight model gives teams direct control over training, deployment, and update schedules. Whether that control is worthwhile depends on the workload and the hosted alternatives available. The evidence for adapting open models is strongest on narrow tasks: LoRA Land found 4-bit LoRA fine-tunes beat GPT-4 by 10 points on average across 31 tasks, with 25 adapters served on one 80GB A100. This is the strongest case for teams that want to fine-tune a small model on company data.
The savings on LLM inference often far outweigh the cost of generating training experience, scoring it, retraining, and validating. If you go this route, the Model Gateway can send a share of traffic to an adapted model.
How do you build a self-improving agent you can trust?
Start with evaluation, because every later step depends on a score you trust. Then pick the cheapest change that fixes the failures you see: memory for repeated lessons, tool or workflow changes for repeated procedural mistakes, and model training only when the workload justifies it. For most teams, the first self-improving agent runs on the model they already use.
Chalk gives each part of that loop a home. Point-in-time correct data replays each agent input as it was at the moment of the original task, so a change is scored against what the agent could have known. Agent evals pin the dataset, task, and scorer versions so every candidate is judged the same way. Sandboxes give agents that edit their own tools or workflows an isolated place to run.
Want to see the full loop running? Talk to an engineer about the agent you would improve first.
