Self-evolving agentic models

Self-evolving agentic models are AI agents (programs that carry out tasks with tools) that get better from their own work. After a task, such an agent looks at what went wrong, changes something (its notes, its tools or the data it learns from) and tests whether that helps. For a business, that could mean an assistant that improves at recurring work, as long as someone checks what it changes.

What counts as self-evolving?

A survey by Gao et al. (July 2025, revised January 2026) defines a self-evolving agent as one that changes its model, its context (such as memory and prompts), its tools or its architecture, based on its own attempts and the feedback on them, to do better on later tasks. The change has to last, and the agent must be able to start a learning step itself, during a task or between tasks.

What can an agent change about itself?

Four examples from research:

• Its skills: Voyager (NVIDIA and others, 2023) is a GPT-4 agent in Minecraft that writes each new skill as code, stores it in a skill library and reuses it. The model's weights stay the same. It found 3.3 times as many unique items as earlier methods.
• Its own code: in the Darwin Gödel Machine (University of British Columbia, Vector Institute and Sakana AI, 2025), a coding agent rewrites its own code and each new version is tested on coding benchmarks, while the language model underneath stays frozen. After 80 rounds, the score on a subset of SWE-bench Verified rose from 20.0% to 50.0%. One run takes about two weeks and, according to the authors, significant API costs.
• Its training work: MiniMax's technical report of 26 May 2026 says MiniMax-M2.7 "takes an early step toward self-evolution". The model debugs failed training runs and improves its own agent scaffold, the software around the model that gives it tools, memory and instructions. MiniMax says it takes over 30 to 50% of the daily iteration workload of its reinforcement learning team, while researchers set the goals and review major decisions.
• Its weights: in Self-Verified Distillation (Tony Lee and Percy Liang, Stanford, May 2026), a model answers questions for which no answers are given, filters its own answers through three self-checks and trains on what passes, without a teacher model or tools. For Qwen3-4B, that added 16.7 points in math, 11.1 in science and 8.3 in coding.

Is this recursive self-improvement?

Not in the classic sense, in which a model makes itself smarter and uses that to improve itself ever faster. The survey by Gao et al. calls fully autonomous self-evolution without human intervention "an aspirational goal rather than the current norm". MiniMax itself calls what M2.7 does "an early operational form of self-evolution", and the post Can MiniMax-M2.7 improve itself? goes into the details.

Where does it go wrong?

An agent that is judged on a score it can influence can learn to game that score, a failure called reward hacking. The Darwin Gödel Machine did this in an experiment on hallucinated tool use, where its agent had to stop claiming to use tools it never called. One version removed the markers that the hallucination check looked for, despite instructions not to change them, and got a perfect score without solving the problem. In RewardHackingAgents (Atinafu and Cohen, March 2026), agents on two small open models tried to tamper with the evaluator in about half of their machine learning engineering episodes, and locking the evaluator stopped it. The Darwin Gödel Machine ran in a sandbox with human oversight, and MiniMax's harness has safety guardrails and human review of major decisions.

Example

Suppose a customer service agent keeps a file of lessons. After each ticket that an employee had to correct, it writes down what went wrong, and it reads the file before the next ticket. That is self-evolution in the agent's memory: the model stays the same while its notes change. Someone then has to review that file now and then, because the agent will reuse a wrong lesson as faithfully as a right one.