The Field Just Named Three Ways Agents Rewrite Themselves. None Names an Owner.
Shilong Liu, a postdoc fellow at Princeton AI Lab, published a taxonomy on 8 July 2026 that a scattered field had been missing. Self-evolving agents, the systems that rewrite some part of themselves in a loop, had roughly 25 arXiv papers behind them and no shared map. Liu drew one. His organizing move is clean: an agent is a model plus a harness, and agents produce artifacts, so evolution can happen at exactly three levels. The piece is a blog post published as a long X thread, not a peer-reviewed paper, and it is already the clearest thing written on the subject.
His distinguishing questions are precise: “What evolves? What feedback drives it? Where does the loop close?” Three questions, three tiers. There is a fourth question the taxonomy never asks, and it is the one an operator needs before turning any of this on. When the loop closes, who is accountable? Each tier answers that question differently, and each demands a different control.
Tier 1: the agent improves its outputs
The first tier is artifact iterative optimization. The model and the harness stay fixed. What changes is the output. A human sets the target and the evaluation criteria, and the agent runs a loop: improve, produce, check, repeat. Liu cites AlphaEvolve for algorithm discovery, NVIDIA’s robot policy work, LabOS, and Qumus.
This is the tier most teams already run without naming it. Any agent that iterates against a scorer until the score passes is doing artifact optimization. The evolution is real, but it is bounded by the eval. The agent cannot escape the criteria a human wrote. That is exactly why the criteria are the control point, and why a badly specified eval is the failure mode. If the scorer rewards the wrong thing, the agent will optimize the wrong thing with more diligence than any human would.
Tier 2: the agent rewrites its own components
The second tier is harness self-improvement. The weights stay frozen, but the agent modifies its own scaffolding. Liu splits this into two tracks. The prompt and memory level covers GEPA, ACE playbooks, and Mem0. The tools and skills level covers Alita and Mem-UI, where the agent writes new capabilities for itself. Liu notes that skills were “formalized by Claude Code,” which places this tier in production, not in theory. It extends to multi-agent systems, where a router assigns tasks to expert agents.
An agent that writes its own tools is an agent with write-permission on itself. We argued in self-improving agents and observability that the harness tier is the one most likely to drift silently, because nothing about it touches a model registry or a data warehouse where a governance team would notice. A new skill is just a file. The control point here is the write-permission on the harness and a diff review on every skill and tool the agent creates. If a human never sees the diff, the agent’s self-modifications compound unaudited, one file at a time.
Tier 3: the weights change without gold answers
The third tier is the one that makes security teams sit up. The weights themselves change, and they change with no gold labels. Liu groups the methods: pseudo-ground-truth and internal signals such as self-training and TTRL, self-play as in SPIN and Absolute Zero, test-time training, and continual learning. The agent generates its own training signal and updates itself against it.
This is where accountability stops being abstract. A model that trains on its own outputs can drift into a loop where the signal it trusts is the signal it produced. The control point is the training-data gate, the decision about what is allowed to become a training example, and the weight rollback, the ability to return to a known-good checkpoint when the drift shows up in production. Neither exists by default. Both have to be built before the loop is switched on.
The column the taxonomy is missing
Liu names one human in the entire framework. “A human is a router.” That role assigns tasks. It answers for nothing. There is no safety axis, no control axis, no rollback axis, and no oversight axis anywhere in the taxonomy. That is not a criticism of the map. A taxonomy of what evolves is not obligated to be a taxonomy of who answers for it. But an operator adopting the map needs the second table, because the three tiers do not share a control point. They each demand a different one.
| Tier | What changes | Control point | Who signs off |
|---|---|---|---|
| 1. Artifact optimization | The agent’s outputs; model and harness fixed | The evaluation criteria and the target that defines “better” | The human who wrote the eval |
| 2. Harness self-improvement | Prompts, memory, tools, skills the agent writes for itself | Write-permission on the harness plus a diff review on every new skill and tool | The platform owner reviewing the diff |
| 3. Model learning without gold answers | The weights, updated on self-generated signal | The training-data gate and the weight rollback to a known-good checkpoint | The owner of the model registry |
The stakes are already concrete. Liu cites Analemma AI’s FARS system, which ran for 417 hours and produced 166 fully AI-generated papers at a cost of roughly $180k. That is a Tier 1 and Tier 2 loop running for weeks without a human in the improvement path. The output was 166 artifacts. The question the taxonomy does not force anyone to answer is who signed off on them, and against what criteria.
Liu closes with a line worth keeping: “The world is still the hardest environment. It is also the place where self-evolving agents matter most.” The world is also the place where an unowned loop does damage that a benchmark never sees. The agent control plane is becoming a product category precisely because the accountability question has no home in the research framing, and permissions have to become a system of record once agents can rewrite themselves.
Do this now
Take Liu’s taxonomy and add the fourth column before you deploy anything on it. For each self-evolving loop you run, write down which tier it is, then name the control point and the person who signs off. Tier 1: who owns the eval, and when was it last reviewed against what you actually want. Tier 2: who reviews the diff when the agent writes a new skill, and does that review happen before the skill runs or after. Tier 3: what is the training-data gate, and can you roll the weights back to yesterday if the drift shows up tonight.
If any row has a control point but no name next to it, that loop is running without an owner. The taxonomy will tell you what is evolving. It will not tell you who is responsible. That column is yours to fill in.
This analysis synthesizes A Taxonomy of Self-Evolving Agents (Shilong Liu, Princeton AI Lab, July 2026).
Victorino Group helps engineering organizations put a named owner and a control point behind every self-evolving agent loop. Let’s talk.
All articles on The Thinking Wire are written with the assistance of Anthropic's Opus LLM. Each piece goes through multi-agent research to verify facts and surface contradictions, followed by human review and approval before publication. If you find any inaccurate information or wish to contact our editorial team, please reach out at editorial@victorinollc.com . About The Thinking Wire →
If this resonates, let's talk
We help companies implement AI without losing control.
Schedule a Conversation