The organizing map for self-evolving AI — the series that sits above this blog's two mechanism-level self-evolving-agents series and answers three questions for any system wearing the label: what evolves, what feedback drives it, and where does the loop close? The anatomy (model, harness, artifact) and the three loci of evolution: artifact evolution in depth (the generate–evaluate–refine loop as evolutionary computation with an LLM mutation operator; the verifier spectrum from exact checkers through measured execution and test suites to proxy scores and LLM judges, with each tier's signature failure and the pressure-budget rule), harness evolution located rather than re-taught (context, capability, and structure sublayers; the four structural reasons scaffolding dominates production; the elicit-never-exceed ceiling and its symptoms), and model evolution without gold answers (consensus as pseudo-truth, self-play as curriculum, verifier reward, environment signal — and the shared circularity of training on model-shaped data, contained by anchors, held-out evaluation, and deploy-grade gating; test-time training as weights-deep adaptation at cache-entry blast radius; continual learning, catastrophic interference, and the replay/regularization/isolation triad under the stability–plasticity dilemma). Then the two cross-cutting axes: feedback (the five-type strength ladder, Goodhart thresholds, and the cascade architecture with inter-stage agreement as the drift alarm) and loop closure (within-task to online-continuous, with gating rising to match blast radius) — closing on composed stacks, three-axis governance, and delivered artifacts as the only ungameable success metric. Grounded in Wikipedia (recursive self-improvement, software agents, genetic programming, evolutionary computation, automated theorem proving, software testing, self-modifying code, semi-supervised learning, reinforcement learning, catastrophic interference, online machine learning, Goodhart's law, feedback, scientific method).
The phrase "self-evolving agent" gets attached to systems so different that arguments about it are usually category errors: an agent that rewrites its own prompts, a loop that breeds faster GPU kernels, and a model that updates its weights from its own consensus answers are all "self-evolving" — and almost nothing else about them is alike. This series builds a working taxonomy by asking three questions that dissolve the terminology fights: what evolves, what feedback drives it, and where does the loop close?
The anatomy — model, harness, artifact — and the three loci of evolution: artifact (improve the products), harness (improve the scaffolding), model (improve the weights without gold answers), crossed by two axes: what feedback drives the loop and where it closes. Three questions replace the definition fights. Opens the series.
The least philosophical form of self-evolving AI is also the one with the hardest results to argue with: hold the model fixed, hold the harness fixed, and evolve the artifact — the program, the schedule, the mathematical construction — through thousands of generate-evaluate-refine rounds. This post dissects that loop: why it's evolutionary computation with the mutation operator replaced by a language model, why the evaluator is the entire ballgame, and what changes when the LLM is both the operator and, increasingly, the optimizer.
Artifact evolution is evolutionary search with an LLM as the mutation operator — population, generator, evaluator, selector — where the LLM contributes semantically valid, evidence-driven edits and the evaluator contributes everything else. Offline loop, mechanical feedback, externally checkable results: the honesty standard for the rest of the map.
Artifact evolution's track record is strangely lumpy: superhuman results on matrix-multiply schedules and scheduling heuristics, respectable results on general code optimization, and little to show on "write me a better product strategy." The lumpiness isn't mysterious — it traces exactly one variable: how good a verifier the domain affords. This post organizes the application domains along that spectrum, from exact checkers to vibes, and reads off where the loop is trustworthy, where it needs guardrails, and where it quietly becomes fiction.
Artifact evolution's lumpy track record traces one variable: verifier strength. The spectrum — exact checkers, measured execution, test suites, proxy scores, LLM judges — with each tier's signature failure, the pressure-budget rule, and the highest-leverage move: reshaping problems toward checkability.
Between the artifact loop's external modesty and the weight loop's internal stakes sits the locus where nearly all deployed self-improvement actually happens: the harness. Prompts that rewrite themselves from failure analyses, memories that accumulate, skills that get written once and reused forever, routing that restructures — the model never changes, and the agent gets better every week. This post places harness evolution on the taxonomy and explains the structural reasons it dominates practice — then hands the mechanisms to the two series on this blog that cover them in depth.
Harness evolution dominates production for four structural reasons — text-native and reviewable, file-write cheap, scoped blast radius, weak-feedback tolerant — and splits into context, capability, and structure sublayers mapped onto this blog's existing deep dives. Its hard ceiling: it elicits frozen-model ability, never exceeds it.
The deepest locus of self-evolution is the weights — and the interesting frontier there is not supervised fine-tuning on human labels but the family of methods where the model improves from signals it generates or uncovers itself: pseudo-labels from its own consensus, rewards from self-play, curricula it proposes to itself. This post organizes that family by one question — where does the training signal come from when no gold answer exists — and traces the shared failure mode every branch inherits: a model learning from itself can amplify its knowledge, and can just as efficiently amplify its errors.
Label-free weight evolution sorted by signal source: consensus as pseudo-truth (sharpens knowledge, launders bias), self-play as curriculum (risks private equilibria), verifier reward (internalizes verifier exploits), environment signal (honest, slow, governance-heavy). One shared circularity — training on model-shaped data — and the anchor discipline that contains it.
Post 5 asked where the training signal comes from; this post asks when the weights change — and the two most radical answers bracket the question. Test-time training updates weights during inference, per input, then throws the update away; continual learning updates weights forever and keeps them. One treats adaptation as disposable, the other as permanent — and between them sits the oldest unsolved problem in neural networks: learning the new without trampling the old.
Test-time training adapts weights per input and discards the update — the deepest locus at the narrowest closure; continual learning keeps updates and collides with catastrophic interference, managed by replay, regularization, and isolation. Underneath both: the stability–plasticity dilemma and the two-timescale resolution that meets the memory series.
Walk back through the first six posts and a pattern repeats with suspicious regularity: the artifact loop is only as good as its evaluator, consensus training launders whatever bias the vote shares, self-play drifts without an anchor, test-time adaptation mis-fires when its proxy objective lies. Different loci, same lesson. This post makes the lesson the subject: feedback is the taxonomy's second axis, failure modes sort by feedback type rather than by locus — and the engineering discipline of self-evolving systems is mostly the engineering of feedback.
Feedback is the taxonomy's second axis: five types on a strength ladder — formal, mechanical, environmental, judged, self-consistent — each with a signature failure, all governed by Goodhart at type-specific pressure thresholds. The universal architecture is the cascade: cheap filters, strong gates, inter-stage agreement as the drift alarm, humans as calibrators.
The series mapped three loci and a feedback axis as if systems politely stayed in one square of the grid. They don't — the direction of the field is composition: artifact loops whose lessons distill into the harness, harness accumulation that consolidates into weights, each locus covering the others' weaknesses. This closing post adds the final axis — where the loop closes — then assembles the full map, reads off the governance that composition demands, and ends on the only success metric that resists gaming: what the system actually delivers.
The third axis — loop closure, from within-task to online-continuous, with gating rising to match — completes the map. The frontier is composed stacks: artifact loops feeding harness distillation feeding rare, gated weight consolidation under monotone feedback strength. Governance reads off the three axes; success is measured in delivered artifacts. Closes the series.
This series is part of a larger body of work by Pratik Dhanave, an Agentic AI Architect writing about production AI systems, distributed systems, and cloud-native engineering. Explore all course series, browse every post, or find topics via the tag index.