Self-Evolving Agents

Concept page. An agent is self-evolving when it improves its own behavior after deployment without a human writing the next round of code, prompts, or training data. The agent observes its own runs, extracts what worked and what failed, and feeds that back into one or more of its own parts.

The field has split the "self" into two distinct levers, and most of the confusion in the literature comes from conflating them:

• Harness updates (the scaffold around the model). A meta-agent rewrites tools, prompts, retry logic, memory, and the search procedure while the model weights stay frozen. This is the "agent harness" object that Scaling the Harness (05-27, the position paper arguing system scaling, not model scaling, is the next bottleneck, with six harness components) named as a first-class design surface. Lineage: Darwin Godel Machine, Meta-Harness, Hyperagents.
• Weight updates (the model itself). A test-time training loop updates the model's own parameters on task feedback while the harness stays fixed. Lineage: TTRL, the Discover test-time-training line.

These two were studied in isolation until 2026-06. The current frontier is combining them, and understanding how each scales.

Two additions that separate the field's conflated faculties (2026-08-13)

The self-improvement literature has been measuring one thing and calling it two. Every result on this page evaluates an agent improving itself, so "can this agent do research" and "can this agent edit itself" have never been independently observable. AutoWorldModel-Bench (2608.11216) separates them: a frontier coding agent gets a working world-model starter, a fixed compute budget, and no specification of what "better" means, then has to pick a research direction itself. World modeling was chosen because it is genuinely unsettled, so there is no known right answer to recover. Across 64 sessions, Codex-5.4 and Claude Opus 4.6 improved their starter on 63, and in 91% of sessions the winning edit was a research-style modification (a new objective, representation, rollout procedure, or architecture) rather than a hyperparameter tweak.

This bears directly on the page's biggest open result. Evo-Bench's unexplained early saturation, where autonomous harness evolution plateaus after few cycles, is the bound on the entire recursive-improvement story, and Mendel Gödel Machine (08-12) proposed one explanation: single-trajectory conditioning is high-variance, so edits mostly correct noise and the curve flattens once single-trajectory-visible defects run out. AutoWorldModel-Bench supplies a discriminating observation. If agents plateau at self-improvement while reliably improving an external artifact 63 times out of 64, the plateau is more likely about the evidence available for self-editing than about a ceiling on research ability. That is now a two-experiment test rather than a hypothesis.

The reconciliation with the negative results also matters. The 08-12 benchmark cluster found the best agent completing 56.70% of real data-science workflows with every open-source agent below 1%, on the same board where agents make research-grade progress in 91% of sessions here. The difference is almost certainly that AutoWorldModel-Bench supplies a dense automatic metric and a pre-parsed structured state and the data-science benchmark supplies neither. Read charitably, that is the most useful thing on either board: agents perform where the environment does the grounding for them, which is a statement about deployment conditions rather than about capability.

Separately, the skill lifecycle now has a paper per stage. The Kurate skills cluster (08-13) collects six papers from one weekly leaderboard, each performing a different operation on the agent skill as primary object: SkillSentry guards it at runtime, SkillProx improves it via proximal textual gradient descent, SkillLens retrieves it visually, BONSAI searches over it with evolvability-guided tree search, a comparative study retrieves it at scale, and EvoMem remembers across evolution cycles. Retrieve, execute, guard, improve, search, remember, with no gaps and no overlaps.

For this page the observation is not that skills are a pattern, which passed the threshold months ago, but that the field has moved from arguing what a skill is to building infrastructure per lifecycle stage, which is a later phase. Two cautions carry: none of the six cites the others, so the apparent convergence may be a shared word rather than shared architecture, and not one of the six reports a cost, which is disqualifying for a lifecycle built on a context-injection artifact that ALTK-Evolve (08-12) showed can be delivered at 41% of the token cost for 8.9 points more accuracy.

State of knowledge (as of 2026-08-12)

The open problem this page has carried since 07-27 got its first direct measurement, and the answer is redundancy.

That problem, stated at the bottom of this page: "does a self-expanding skill library reach genuinely new territory, or does it saturate and refine what it already covers? Every paper in this cluster reports downstream benchmark gains; none reports library growth or coverage over time." SkillZip (08-12) (2608.11079) is the first paper to look at the grown artifact itself, and what it finds is not new territory. It finds duplication: the same requirement restated across several branches, examples and warnings, and common action sequences copied rather than referenced. The entire method presumes the library is substantially compressible, which is a redundancy measurement standing in for the coverage curve nobody has plotted. That is evidence for the saturation branch, though SkillZip frames it as engineering rather than epistemics and does not plot growth against coverage either.

The method is the first in this cluster whose objective function is the cost. SkillZip compresses a skill by finding its shortest faithful structural explanation, under a typed minimum-description-length objective over a skill contract and a residual, subject to a hard coverage constraint on every extracted trigger, workflow edge, tool requirement, obligation and output field. The intuition is explain once, reference many: state a repeated rule once at the scope where it applies, factor a repeated action sequence into a shared procedure, keep only genuine differences as explicit exceptions. Crucially it is evaluation-free, meaning no rollouts. Every prior compressor in this setting is evaluation-guided, which costs rollouts and makes the result depend on whichever tasks were in the compression-time evaluation set. Because coverage is checked structurally rather than behaviorally, rare unique rules survive by construction rather than by hoping a sampled task activates them, which matters because a rare exception is what a sampling-based compressor deletes first. Two modes: one-shot, and Zip-on-Write, which folds each self-evolution patch in without replaying tasks or reparsing history.

This closes, partially, the cost hole this page opened on 08-11. The 08-11 entry below recorded of Ouroboros, Evo-Bench and A²E: "Cost is the unpriced variable across all three." SkillZip does not price the evolution loop, but it prices the artifact the loop produces, which is the recurring half of the bill. A skill is injected on every step forever; evolution is paid once. That is the right half to attack first.

And the confirmation came the same day from industry with the numbers the paper withholds. IBM Research's ALTK-Evolve (08-12) attacks the identical bottleneck by the opposite route. Where SkillZip shrinks the artifact, ALTK-Evolve leaves it large and makes delivery adjustable: a small always-on core of high-confidence guidelines plus a per-task subset retrieved by cosine similarity or LLM choice, or the full set when the model has capacity. Against ACE (Agentic Context Engineering, the Generator-Reflector-Curator loop that injects one comprehensive playbook at every step), on AppWorld's 168 tasks: DeepSeek-V3.2 at 89.3% task-goal completion and 263K tokens per task against ACE's 80.4% and 634K, and GPT-oss-120b at 56.0% and 116K against 54.8% and 777K. The DeepSeek row is the important one because both axes move the right way at once, which means the baseline was paying for context that was actively harmful rather than merely redundant.

So the design fork on this page is now compression versus selection, and they are composable. Neither paper cites the other. Nobody has run compress-the-store-then-deliver-a-subset, which is the obvious next experiment and cheap. The secondary ALTK-Evolve finding also explains a result this page has carried since 08-05: SkillBench and PastBench (08-05) found explicit skill maintenance merely matches plain in-context learning on average, with weaker models accumulating more fragments. ALTK-Evolve's per-model calibration says weaker models are hurt by volume while stronger ones absorb it, so a method that dumps everything into every model averages to nothing. The fix is not better skills, it is fewer of them per step for the models that cannot use them.

Standing caveat, inherited and now worse. A compressed or merged skill is still prose, so it stays on the wrong side of the copyable-context trilemma (08-03), and SkillJack (08-05) showed detection of a poisoned skill collapses from 98.5% on the source trajectory to 11.4% on the extracted skill with 80% of attacks surviving deletion of the source records. Both of today's methods perform another abstraction step on top of that one, and merging rules across branches is precisely the operation that would launder a poisoned rule into a shared procedure many branches now reference. Neither paper discusses adversarial input.

The self-modification operator got opened up for the first time. Every system on this page takes "the agent edits itself given a failure" as a primitive. Mendel Gödel Machine (08-12) (2608.07645) asks what evidence the edit should be conditioned on, and observes that all prior loops condition on one failure trajectory on one task, discarding the archive. It adds reaction-norm mutation (edit using one agent's trajectories across multiple tasks, so a recurring defect can be distinguished from a transient error) and cross-lineage hybridization (edit using a reference agent from another lineage on the same task, so a working behavior can transfer; including the comparison of two failing trajectories to find complementary weaknesses). Faster convergence proven under an additive fitness landscape, which is the assumption most favorable to recombination, plus surrogate simulation and gains on SWE-bench and Polyglot.

MGM is a candidate explanation for the result this page called its most important unexplained one. Evo-Bench's early saturation would follow naturally if each cycle conditions on one trajectory: the edits are high-variance and largely corrective of noise, so the curve flattens once single-trajectory-visible defects are exhausted. The falsifiable test is to run Evo-Bench with MGM's operators and see whether the saturation point moves. MGM does not do this. Its costs also move the wrong way, since both new operators need more trajectories or more lineages per edit than clonal mutation, and "faster convergence" is reported in cycles rather than dollars.

A taxonomy arrived for the environment-side turn this page noticed in June and never named. The Co-Evolution survey (08-12) (2608.10299) argues single-entity self-evolution is bounded by a static learning context and orders the field by how much human-engineered constraint has been shed: Stage 1 Agent-Agent (adversarial, collaborative, organizational), Stage 2 Agent-Environment (adaptive tasks, feedback, interaction spaces), Stage 3 Meta (the evolution mechanism itself becomes evolvable). Stage 2 is exactly the "evolving environment turn" this page logged on 2026-06-14 from EvoArena/EvoMem, Evoflux and EvoBrowseComp. The ordering-by-shed-constraint is better than a technique taxonomy because the safety story falls out of the same axis as the capability story: every rung up removes a place a human had specified something, which is both the gain and the lost review point. What the survey does not carry, and what this page's existing material says is the one design question already answered, is whether decoupled objectives are necessary. DecoEvo (07-30) is the standing answer: if one side's updates are selected by the other side's score, the pair learns that an easier task raises the score.

The gap between this page and measured capability widened for a third consecutive day, and should now be treated as the page's central tension. The same 08-12 board carried three benchmarks in which the best agent available completes 56.70% of real end-to-end data-science workflows (DSAgentBench, with every open-source agent below 1%), 57.3% on personal-information assistant tasks (SPIEval), and all seven frontier models scoring low on multi-week proactive life tasks (VibeLifeBench). Two of the three diagnose the same failure, and SPIEval measures it: 79% of failures are inaccurate information localization, with fewer than 2% of retrieval actions using any advanced search method. That is the cheapest published measurement of the faculty this page named on 08-06 as the common missing one across four negative results, deciding what to do with a resource you already have. It is not that agents search badly. They mostly do not search, then commit to a plausible guess. A recursive-improvement literature and a measured-capability literature published on the same board are describing different objects.

Industry reached this page's economics conclusion independently, and solved one of its open problems as a product requirement. Ben Lorica's continual-learning survey (08-12) counts more than twenty startups on the deployed-learning loop and states the economic case almost as SkillZip does: you pay to reprocess the same information every session, so frequently used information should be compressed into the system rather than re-read. More pointedly, he reports that these companies build regression checking into the update loop rather than trusting a human to notice later, because that is "what separates improvement that compounds from an expanding pile of patches." ScrambleToolBench (08-04) concluded the missing operation in agent memory is invalidation, not storage or retrieval, and Honest Lying (06-09) showed why, with 0 of 121 reflections naming the correct object across 16 frozen environments. Industry made invalidation table stakes while the literature was still naming it a gap.

Also new: the horizon test this page has been asking for exists now. The standing complaint here is that everything is validated on episodes of dozens of steps rather than days, so "whether learned curation survives at the horizon where drift actually appears is the untested question that matters most." VibeLifeBench's multi-week scripted timelines, with a world that advances on its own clock and changes silently so only an agent that re-inspects discovers them, graded only on durable artifacts, is that horizon in a simulator. It is the natural target for RoMeRL (08-11)'s bounded memory states and SkillZip's compressed skills. Neither has been run on it.

State of knowledge (as of 2026-08-11)

The harness lever this page defined in May got three papers in one day, and one of them has been running for 161 days.

This page's founding distinction is between harness updates (rewrite the scaffold, freeze the weights) and weight updates (test-time training, freeze the scaffold). Today the harness lever produced a system, a benchmark and a measurement layer simultaneously, which is the shape of a subfield forming. See the combined summary (08-11).

The system. Ouroboros (2608.08311) is a self-developing coding-agent harness whose tools, prompts, context assembly and core implementation improve through reviewed commits that then become the runtime for later work. Two modes: recursive free evolution, where improvement is itself a task and completing one cycle can schedule the next, and experience-driven core evolution, where ordinary work and social interaction expose faults that lead to reviewed structural changes. On Opus 5: Terminal-Bench 2.1 86.74% and OSWorld-Verified 90.69%, both reported as best known, plus a new CL-Bench state of the art at 0.2301 normalized reward. The important artifact is Hope, a 161-day living deployment under free evolution across seven human-interaction surfaces where humans surface faults and propose changes but the agent decides which to pursue. Benchmarks run on frozen snapshots; Hope evolves on a separate lineage, which is methodologically honest and also means the record scores are not evidence that five months of free evolution improves anything.

This escalates the lever past everything else on this page. Scaling the Harness (05-27) named six harness components as a design surface. SKILL-KD (08-06) distils a student failure against a teacher success into an editable natural-language skill patch, verifies it by re-running the student, and consolidates patches with trace-linked edit histories to prevent skill drift. SkillProx (Kurate cs.AI #10 this week) evolves skills via proximal textual gradient descent. All of those evolve artifacts the harness consumes. Ouroboros evolves the implementation itself, which is a strictly larger blast radius, and the reviewed-commit gate is the only thing between it and an unbounded rewrite. The authors say so directly: because a self-developing agent may rewrite its own code and select new model APIs, guardrails must remain authoritative under evolutionary and public social pressure. They assert this as a design requirement and report no adversarial test of whether it held over 161 days.

The benchmark, and its most interesting number is a negative one. Evo-Bench (2608.09096) isolates harness-evolving capability from base model strength using auxiliary-task evolution to find tasks genuinely sensitive to framework improvement, then sensitivity-aware stratified splitting. Across nine frontier and open-weight models, top models gain up to 16.6 absolute points, approaching human-engineered baselines, and autonomous evolution beats human harnesses on General tasks and excels at Search. But it struggles on Office tasks demanding highly specific workflows, and it reports early saturation as a temporal anomaly. That saturation finding is the single most important unexplained result for this page, because if autonomous harness evolution saturates early then the recursive-improvement premise is bounded and the bound is the whole story. Evo-Bench also finds synthesized harnesses act as highly transferable reasoning structures that lift diverse policy models, which is the strongest evidence yet for DSPy's task-model separation claim (07-25) that the specification is a portable artifact with value independent of the model it was tuned against.

The measurement layer, and it hands this page a routing question. A²E (2608.07346) introduces an Agent Task Protocol for integrating tasks across harnesses, an instrumented Monitor producing standardized execution traces, and metrics for execution efficiency, tool use, task planning and error recovery rather than correctness alone. Its finding: model-harness combinations vary substantially by task type and no single combination consistently wins. That is the premise of llm-routing.md moved one level up the stack, and nothing currently deployed routes over harnesses.

Cost is the unpriced variable across all three. Recursive free evolution spends model calls improving the harness rather than doing user work. Neither the 16.6-point gain nor Ouroboros's records are reported in tokens or dollars, which makes them incomparable to any fixed-harness baseline.

The governance collision is immediate and this page should log it. The WAIC Frontier and Agentic AI Safety Forum takeaways (08-11) record Shanghai AI Lab's Zhou Bowen arguing that because AI is beginning to recursively self-improve, safety must be re-proven every generation, and Alibaba's Yang Xiaofang noting that monitoring behavior is insufficient once agents build other agents. Import AI 468 leads with 23 policy ideas for handling recursive self-improvement. No current governance framework, including the L1–L5 agent autonomy white paper launched at WAIC, has a review gate that assumes the artifact under review rewrites itself between reviews. Ouroboros has been doing exactly that in public for five months.

State of knowledge (as of 2026-08-10)

The strongest positive result yet for a self-directed agent loop arrives with the exact cost omission that this week's best negative result exists to expose. ReASearch (08-10) (2608.06714) deletes the outer-loop controller. Systems that optimize prompts, programs and ML workflows almost all wrap a language model inside explicit evolutionary search, a bandit, or a textual-gradient method. ReASearch internalizes that policy into a single tool-using agent that decides what to evaluate, how to diagnose a failure, which edit to make, and when to verify or restart, carrying strategy across a long horizon in persistent memory. One scaffold with swapped domain tools covers all three targets, and across 14 tasks it is competitive with and mostly better than specialized systems by 2% to 40%, in some cases improving on prior human best-known results. The paper's claim is that search behaviors normally hand-coded as controller logic emerge from the agent's reasoning.

The missing number is tokens. An agent that reasons at length before each edit spends far more per candidate than an evolutionary controller does, and there is no matched-token comparison, so the 2-to-40% range is not like-for-like. This is exactly the hole the Sample More Reflect Less study opens in the adjacent literature (DAIR.AI weekly roundup, starred Gmail 08-10): seven self-improvement methods, open models at 1.5B, 3B and 7B, two math benchmarks, every generated token counted including critiques, reflections, debate turns and checking, each method compared against plain repeated sampling at its own measured cost, with paired bootstrap intervals and multiplicity correction. Repeated sampling held up against every method in every setting across all 36 comparisons. Ten comparisons were reliably worse and every one involved the model inspecting its own output; all 18 self-inspection comparisons were negative. Reflexion as published never triggered its own retry on the smallest model, because it judged itself correct every time. ReASearch is not a self-inspection method, but its mechanism is "generate more reasoning," and it is not held to that standard.

The reconciliation this page should adopt, because it also explains the page's biggest prior contradiction. Shadow evaluations (08-06) gave frontier agents six days and thousands of dollars of credit on genuine unpublished research questions and both runs ended with under 50% of budget spent and hours remaining, despite being able to monitor usage and being told to spend down: a pure allocation failure. ReASearch says an agent allocates a search budget well. The difference is the presence of a dense, cheap, automatically computable score. Self-directed allocation works where a verifier exists and fails where one does not, which is the same boundary condition the RLVR literature keeps rediscovering, and it predicts that every "the agent manages itself" result should be checkable against how fast its environment answers.

It also sharpens what persistent memory is worth here. SkillBench and PastBench (08-05) found explicit skill maintenance matches plain in-context learning on average, with weaker models accumulating more fragments. ReASearch's persistent memory is a skill library under a different name and it does pay off, on tasks with tight feedback loops. Together: persistent agent memory pays in proportion to how quickly the environment tells you the memory was right. That is a falsifiable and cheap thing to test, and it is a better organizing claim than the skill-library-versus-context framing this page has been using.

State of knowledge (as of 2026-08-06)

The fourth independent negative result in eight days, and it is the one that names the missing faculty directly. Shadow evaluations (08-06) gave frontier agents six days of wall-clock time, real compute and thousands of dollars of API credits to answer the actual research questions of two unpublished papers, with the original authors reviewing the output. Both agent papers were rejected unambiguously. The five failure modes extracted from over a hundred hours of log reading matter more than the verdict, because four of them are not capability failures: no judgment for open-ended work, where the agents proposed directions expert reviewers found genuinely impressive and then abandoned them on the basis of low-quality or synthetic data; no awareness of their own resources, with both runs ending under 50% of budget spent and hours remaining despite being able to monitor usage and being told to spend down; no creative response to feedback their own self-reviews had already surfaced; no effective backtracking after retiring their most ambitious targets on day one; and no following of explicit process constraints.

Line that up with the three that preceded it and the cluster says something sharper than "not yet." ContinualSkillBench and PastBench (08-05) found plain in-context learning matches explicit skill-library maintenance on average, with weaker models simply accumulating more fragments. SkillJack (08-05) showed the same abstraction step is an attack surface, detection collapsing from 98.5% on a poisoned trajectory to 11.4% on the skill extracted from it, with 80% of attacks surviving deletion of the source records. InMind (07-29) found retrieval-based memory surfaces a fact only when the fact resembles the query, six systems reaching at most 14.4% on indirect queries against 84.0% for memory simply placed in context. Three of the four name the same missing faculty: deciding what to do with a resource you already have. Skill libraries fail because the agent cannot judge which experience is worth abstracting; memory fails because it cannot judge which stored fact is relevant when the query does not resemble it; shadow evaluations fail because it cannot judge which direction deserves the remaining budget. This page has spent months accumulating harness mechanisms. The bottleneck is not the harness.

And the same day produced the sharpest available counter-evidence, which is mostly a vocabulary problem. OneDayAgent (08-06) reports a new state of the art of 0.821 on AgentIF-OneDay across 104 long-horizon "open-ended everyday" tasks, jointly managing goal drift, state loss and context overflow, with the same untuned harness generalizing across five backends from three model families. Self-Evolving Coding Agents (2608.03392) surveys the field as a going concern, and GDPevo (2608.03764) reports self-evolution lifting held-out accuracy by up to 16.44 points on enterprise workflows while remaining far below a 91.6% fully-informed oracle ceiling. The reconciliation is that open-ended in a benchmark name means multi-step and cross-tool, while open-ended in Kapoor and Narayanan's sense means the success criterion is not knowable in advance. Two different problems wearing one adjective, and this page should stop letting the word do both jobs.

One mechanism landed today that is a genuine answer to a gap stated two days ago. SKILL-KD (08-06) builds a skill not by summarizing success but from the actionable discrepancy between a student failure and a teacher success on the same task, verifies the resulting textual patch by re-running the student, and refines while it still fails. Its Drift-Aware Skill Consolidation keeps trace-linked edit histories and decides per patch whether to add, modify, delete or skip a rule. ScrambleToolBench (08-04) concluded that the missing operation in agent memory is invalidation rather than storage or retrieval; consolidation's delete-or-modify branch is exactly an invalidation operation, arriving two days later, though the paper reaches it from library-hygiene motivations rather than from that diagnosis. Two caveats this page should carry: the patch is prose, so the capability lives in context and is therefore copyable, which puts it on the wrong side of the copyable-context trilemma (08-03) and squarely inside SkillJack's laundering path; and today's Skill Entropy (08-06) argues difficulty concentrates in the transitions between skills, in which case a library of per-skill patches improves what was never the bottleneck.

State of knowledge (as of 2026-07-30)

Two papers landed the same day attacking the two halves of self-evolution that the cluster had been leaving fixed: the credit signal for curation, and the evaluator itself.

Making curation an action the policy gets gradient for. SkillRise (2607.26784) collapses the usual multi-stage skill pipeline (extraction, retrieval, execution as separate components that must be kept consistent) into a single policy that alternates between solving a task and curating an evolving skill document passed directly to the next task, over progressively harder task sequences. The mechanism is decoupled credit assignment: solving is supervised by the current task's outcome, curation is supervised by discounted downstream outcomes. That distinction is what separates a skill from a log, because a written skill only earns credit if a later task benefits from it. Results: strongest Pass@1 on ALFWorld, WebShop and ScienceWorld with 2.3 to 8.5 points over the best baseline, and substantially lower runtime overhead than multi-stage pipelines. The load-bearing result is test-time scaling across tasks, with performance improving over longer sequences of related tasks even at one attempt per task, which rules out repeated sampling as the explanation.

This is a third position in the memory debate the page inherited from PRO-LONG (07-27), which argued for a complete searchable log and no compaction, against Agentic Context Management (07-27), which argued for aggressive compaction. Both treat the memory policy as designed. SkillRise learns it, supervised by whether keeping something helped later.

Un-freezing the evaluator without letting it get easier. DecoEvo (2607.25675) names the ceiling every text-space optimization method hits: hold the evaluator fixed and, once the solver satisfies the criteria the rubric measures, every omitted dimension stays permanently invisible to the optimization signal. The naive fix fails in a specific way, because if rubric updates are selected by the solver's score, the optimizer learns that an easier rubric raises the score. DecoEvo co-evolves solver skill and rubric-generator skill under decoupled objectives with no gold rubrics, auditing the generator on two properties that are independent of aggregate solver score: requirement coverage (dropping a hard criterion loses coverage) and response discrimination (asking only easy questions stops separating good from bad). Neither audit can be satisfied by lowering the bar. Best on five benchmarks across three backbones, 2.8 to 5.0% relative over SkillOpt (06-18).

DecoEvo is the first paper in this cluster to pre-empt the self-rewarding audit rather than be exposed to it. The 07-26 digest documented a false-positive basin in LLM judges that transfers across judge families and scales, and predicted a hidden-anchor audit would deflate a published self-improvement result within 60 days; the 07-27 digest named four self-evolution papers as the exposed set. DecoEvo reports its headline under each benchmark's own official evaluation rather than its evolved rubrics, so the self-rewarding loop cannot have inflated it. That moves it out of the exposed set without proving the loop is clean.

Open flag on DecoEvo: the entire anti-gaming argument rests on who runs the two audits, and the abstract does not say. If an LLM judges coverage and discrimination, the generator can learn to satisfy the auditor rather than the property, which is the same failure one level up. There is also no compute-matched comparison, so part of the margin may simply be more search.

Standing counterweight from the same day. Shadow evaluations found frontier agents, given six days and thousands of dollars on a real open research question, completing all engineering and making no research progress, with instruction drift and poor resource awareness among five reproduced failure modes. Every system in this cluster optimizes inside the loop that result says is not the binding constraint, and all of them are validated on episodes measured in dozens of steps rather than days. Whether learned curation survives at the horizon where drift actually appears is the untested question that matters most here.

State of knowledge (as of 2026-06-18)

Skill optimization gives the harness-update lever a clean gradient-descent form. SkillOpt (Microsoft, via Gmail/AI Papers Academy) treats an agent's skill file (the text document of rules, tool calls, and strategies it follows) as a trainable artifact: the agent runs a batch, an LLM reads the full trajectories and proposes edits, and only edits that improve a validation set are kept, with a per-epoch meta-skill update. The framing is explicit, the skill file is the weights, proposed edits are the gradients, the edit budget is the learning rate, validation is the safeguard. It reports SpreadsheetBench lifting GPT-5.5 from 41.8% to 80.7% with no fine-tuning. This is the purest harness-update instance the page has logged, and the instructive contrast is with weight-update siblings the same week: OPD-Evolver (06-17) distills memory-management skill into weights, SkillOpt keeps the equivalent skill in the text artifact and optimizes that. Two opposite homes for one capability, and the open question is whether they compose (SkillOpt the skill, then distill it in) or capture the same gain twice. It also confirms the Disentangling Agent Self-Evolution (06-08) finding that harness-updating is the cheaper, model-tier-flat lever: a validation-gated text loop recovers a large capability jump that fine-tuning would have charged full price for. → summary

State of knowledge (as of 2026-06-17)

A third lever appears: distill the ability to evolve into the weights, instead of building better external memory. OPD-Evolver (arxiv 2606.17628) reframes self-evolution as neither a pure harness update nor a pure weight update, but a slow/fast loop that takes a test-time skill and bakes it into the policy. In the fast loop the agent reads, uses, writes, and maintains a four-level memory hierarchy; in the slow loop it distills those four memory-management abilities into the deployable weights via on-policy self-distillation, using outcome-calibrated memory attribution and privileged hindsight (the same sparse-reward-to-turn-level-credit machinery as PBSD, here applied to memory operations). It beats the external-memory baseline ReasoningBank by up to 11.5% and the training-based Skill0 by ~5.8%, and a 9B variant challenges 397B-scale models. This sharpens the page's central harness-vs-weights tension: where the harness line (HarnessX 06-15, EvoMem / EvoArena 06-14, MemForest 05-26) builds a better external memory store the frozen model operates, OPD-Evolver argues the memory-management policy itself belongs in the weights. It is the agentic instance of the on-policy distillation surge the knowledge-distillation page logged the same day (alongside d-OPSD for diffusion LLMs and ZPPO prompt-channel teaching), and it lands on the same "capability migrates into a learned operating procedure" thread as FastContext (06-16). Open wall, same as the whole self-evolving line: whether the four distilled abilities transfer to genuinely novel task distributions, the actual point of an "evolver," is the unshown result.

State of knowledge (as of 2026-06-15)

"Learn the harness, don't hand-write it" crosses the ≥3-papers convergence threshold. HarnessX (arxiv 2606.14249) is the third harness-as-learnable-object paper in two days, after HarnessBridge (06-14, trains the agent-environment interface as a bidirectional projection that uses fewer tokens than a hand-built harness) and DAIR.AI's Self-Harness (this week's DAIR top-papers list: an agent mines its own model-specific failure clusters into executable harness edits, validated by regression testing, lifting MiniMax M2.5 from 40.5% to 61.9% held-out on Terminal-Bench-2.0, GLM-5 42.9% → 57.1%). HarnessX adds two things the other two lack: a typed compositional substrate (harness primitives assembled by a substitution algebra rather than written as config) and an explicit harness-model loop where traces become both scaffold edits and model-training signal, via AEGIS, framed as an "operational mirror" between symbolic adaptation and RL. +14.5% average across five benchmarks (ALFWorld, GAIA, WebShop, tau³-Bench, SWE-bench Verified), up to +44%, largest where baselines are weakest. With Scaling the Harness (05-27, the position paper), HarnessForge (06-08, harness-policy co-evolution), and these three, the harness-as-first-class-design-surface thesis is now a established convergence, not a hunch. The standing caveat from Disentangling Agent Self-Evolution (06-08) still applies: harness-updating quality is flat across model tiers (a cheap model writes edits as well as a frontier one), so HarnessX's gains most plausibly come from composition + the trace-loop, not from a smarter edit-writer. The unverified-but-interesting claim is AEGIS's symbolic-edit/RL "operational mirror": if a harness edit and a gradient step are genuinely interchangeable improvement operators, you could budget improvement across scaffold and weights by expected return, a routing decision over kinds-of-update. Code not yet released.

State of knowledge (as of 2026-06-11)

Four papers in one day push the frontier from "evolve the agent" to "manufacture the substrate the agent learns from" — environments, harnesses, data, and research strategy all become scalable objects. The day's Agentic Environment Engineering survey (arxiv 2606.12191) is the map: it organizes the field around an environment lifecycle (modeling, synthesis, evaluation, application) and names Environment-as-a-Service as the endpoint. The three concrete systems each take one substrate:

• Strategy substrate — Arbor (arxiv 2606.11926). A long-lived coordinator runs research strategy over a persistent Hypothesis Tree (nodes link hypotheses → artifacts → evidence → distilled insights) while short-lived executors test hypotheses in isolated worktrees. Crucially it admits only verified improvements — the architectural answer to the 06-08/06-09 confabulation worry below. Beats Codex and Claude Code on all six Autonomous-Optimization tasks at >2.5x their held-out gain; 86.36% Any-Medal on MLE-Bench Lite. The coordinator/executor split is the Disentangling routing insight made concrete.
• Harness substrate — EvoTrainer (arxiv 2606.03108). Co-evolves the LLM policy and the training harness through empirical feedback: diagnose rollouts, revise diagnostics, backtest interventions, accumulate reusable skills. Matches or beats human-engineered RL references, largest gain on long-horizon agentic SWE. This is HarnessForge's harness-policy co-evolution (06-08) moved inside the RL training loop. (Summarized with RACES.)
• Environment substrate — RACES (arxiv 2606.12373). Treats verifiable RL environments as typed LEGO bricks: when one environment's output type matches another's input type, they auto-fuse into a new still-verifiable environment, via four operators (SEQUENTIAL, PARALLEL, SORT, SELECT). 50 composed base environments match 300 hand-built ones; +3.1 pts on six unseen benchmarks. This is the safer sibling of EvoEnv (05-15) — composition inherits verifiability instead of re-establishing it.
• Data substrate — DeNovoSWE (arxiv 2606.10728). A sandboxed agentic workflow auto-builds 4,818 whole-repo-from-docs instances (divide-and-conquer + critic-repair), no human labels; lifts Qwen3-30B-A3B on BeyondSWE-Doc2Repo 5.8% → 47.2%. Measured by the same day's harness-aware Claw-SWE-Bench, which confirms empirically that harness choice swings Pass@1 by 27.4 pp — as much as the model (29.4 pp).

The common thread: 2026's agent gains are substrate gains, and the new discipline is making each substrate a scalable, verifiable object. The standing risk from the cluster below — self-generated signal entrenches false beliefs unless an external verifier gates it — is precisely what Arbor's verified-improvement gate and RACES's composition-preserves-verifiability are built to contain.

State of knowledge (as of 2026-06-09)

Two 06-09 papers hit the skill-memory layer from opposite sides: make stored skills cheap, and stop trusting self-generated memory. LatentSkill (arxiv 2606.06087) is the efficiency answer to the skill-library wave (Socratic-SWE, OpenSkill, Skill-RM): instead of injecting textual skills into the prompt every step, a pretrained hypernetwork converts each skill into a plug-and-play LoRA adapter, moving skills from context space to weight space. ALFWorld success +21.4 / +13.4 (seen / unseen) at 64.1% fewer prefill tokens, and the skill LoRAs compose by parameter-space arithmetic, the same hypernetwork-to-LoRA engine as Code2LoRA and Video2LoRA (06-06), new payload. Honest Lying (arxiv 2605.29463) is the cold-water counterpart: Reflexion-style agents store confident-but-wrong task interpretations and keep acting on them across resets (16 frozen ALFWorld environments where 0 of 121 reflections name the correct object). It introduces the Reflection Repetition Rate to detect this, and shows programmatic failure extraction beats open-ended self-diagnosis (0% to 86% correct-object mention). This continues the 06-08 Self-Revising Discovery Systems worry (is self-improvement real or confident remixing?) and the ToolMaze over-trust pathology: self-generated signal, whether a reflection or a mined trace, reinforces false beliefs unless an external verifier gates it.

State of knowledge (as of 2026-06-08)

Combining both levers beats either alone

SIA (06-08, Hexo Labs) is the first system to update both the harness and the weights in one unified loop. A Feedback-Agent rewrites the scaffold and runs weight updates on a task-specific agent. Combining both beats scaffold-iteration alone on three contrasting domains: +56.6% on LawBench (Chinese legal charge classification), 91.9% runtime reduction on GPU kernel optimization, and +502% on single-cell RNA denoising. The stated division of labor: harness updates make the model agentic (how it searches and acts), weight updates build domain intuition no prompt can instil.

HarnessForge (06-08) reaches the same conclusion from the co-evolution angle: it formalizes an agent system as a harness-policy pair and co-evolves them via fault-guided harness tailoring plus harness-conditioned policy alignment, beating harness-only and policy-only baselines by up to 12.0% on five benchmarks. Its sharpest claim is that executable compatibility between harness and reasoning policy is essential, the two cannot be optimized in isolation.

But a stronger model does NOT make a better self-evolving agent

This is the load-bearing 06-08 finding. Disentangling Agent Self-Evolution (06-08, via DAIR.AI) separates harness-updating (an evolver model writes edits) from harness-benefit (a solver model exploits those edits) and shows they scale completely differently:

• Updating is flat across model tiers. Edit quality barely depends on model strength. Updates written by Qwen3.5-9B match those from Claude Opus 4.6. Paying for a frontier model on the evolver side buys almost nothing.
• Benefit is non-monotonic. Weak solvers gain little (they cannot activate or follow the harness component), mid-tier solvers benefit most, and the strongest solvers benefit less (they already solve the task without the scaffold).

The practical lever: put a cheap model on the evolver, spend your capability budget on the solver. This is a routing insight in disguise (see LLM routing), and it directly tempers SIA's enthusiasm: if updating is flat across tiers, the gains SIA reports come from the combination and from the weight-update lever, not from a smarter scaffold-writer.

Where the training signal comes from

The other 06-08 theme is the substrate a self-evolving loop learns from:

• Socratic-SWE (06-08, SJTU + Alibaba) reuses the agent's own historical solving traces, distilling them into structured skills that summarize recurring failures and repair patterns, then generating targeted repair tasks graded by a solver-gradient-alignment reward. 50.40% on SWE-bench Verified after three iterations. The curriculum adapts to the agent's evolving weaknesses, unlike fixed bug-injection synthesis.
• OpenSkill (06-08) tackles the hardest case: open-world deployment that supplies neither curated skills nor verifier signals, only a task prompt. The agent builds both its skills and its own verification anchors from documentation, repos, and the web, then practices against self-built virtual tasks. Its self-built verifier aligns with ground truth despite never accessing it, and skills transfer across models.

This builds on the earlier self-evolving cluster: EvoDS and MLEvolve (06-05, self-evolving data-science / ML-discovery agents), SEPO (06-05, self-evolving prompt agent), SkillOpt (05-25), Ctx2Skill (05-05), and EvoEnv (05-15, self-evolving RL via environment synthesis).

AREX (2026-07-25): verification as the round boundary, and a learned compressor to survive it

AREX (2607.21461, Beijing Academy of Artificial Intelligence, HuggingFace's top paper of 07-24 at 122 upvotes) is the first entry on this page that answers the compounding vs collapse open problem below with a structural argument rather than a longer run.

Its premise is the discovery-verification asymmetry: finding an answer that jointly satisfies many constraints is expensive, while checking a candidate decomposes into cheap constraint-wise tests. Prior work used verification either to rank finished trajectories (best-of-N) or as a local critic inside one. AREX makes the audit the transition between research rounds. The output of an audit is not a score, it is a partially verified state (this claim holds, this one does not, this one is unchecked), and that state defines the next round's research question.

That is why it plausibly compounds where a summary-carrying loop drifts. A running summary can degrade silently across iterations; a ledger of "these constraints are confirmed, these are open" cannot degrade in the same way, because every entry is re-checkable. The second piece is what keeps the ledger from drowning the context: AREX learns its own context-update tool inside the loop, so the compression target is what its own downstream reasoning needs (verified evidence plus unresolved constraints) rather than a generic summarizer's notion of salience. Training is agentic mid-training on verified synthetic tasks, then long-horizon RL that emphasizes the key steps where decisive evidence arrives or a wrong direction is corrected, because a single sparse final reward carries almost no signal over a long research trajectory. Two instantiations, a dense 4B and a 122B-A10B MoE, beat comparable-scale baselines on BrowseComp, WideSearch, DeepSearchQA, and Humanity's Last Exam.

It also tempers the page's cheap-evolver recipe. Disentangling Agent Self-Evolution (06-08) found harness-updating quality is flat across model tiers, so you should put a cheap model on the evolver and spend the budget on the solver. AREX's outer loop is not writing harness edits, it is running constraint audits, and audit quality plausibly does scale with model strength. Whether "updating is flat" survives when the evolution step is verification rather than scaffolding is untested and directly falsifiable.

Related, from the same HuggingFace batch: Experience Distillation (2607.21051, Monash + ByteDance Seed) attacks the durability half of the same problem. Socratic-SWE (06-08) and Ctx2Skill (05-05) both turn agent history into a skill library that lives outside the weights, which keeps the harness-benefit activation problem alive (a weak solver cannot activate the scaffold, a strong one does not need it). Experience Distillation puts the experience in the parameters instead, where there is nothing to activate: collect trial-and-error once, let in-context learning exploit it, then distill the behavior of the context-loaded teacher into a student that has no context, with zero further environment interaction. It retains at least 64.8% of the in-context gain where plain supervised fine-tuning on the identical transcripts recovers 3.8%, because SFT teaches the agent to imitate a record that is mostly failure while distillation targets the behavior of a model that has already absorbed those failures.

The open question the pair raises: neither runs the cycle twice. AREX compounds within a single task, Experience Distillation compounds within a single collect-and-distill pass, and nobody has yet reported collect, distill, collect again with the improved agent. Whether that loop accumulates or saturates is now the most interesting untested claim on this page.

Open problems

• Does the cheap-evolver finding survive harder tasks? Disentangling tested a finite task set. If frontier evolvers eventually pull ahead on genuinely novel scaffolding, the routing recipe flips.
• Verifier bootstrapping. OpenSkill's self-built verifier working without ground truth is the riskiest claim in the cluster, the whole loop's safety rests on it.
• Compounding vs collapse. None of the 06-08 papers runs the loop long enough to show whether self-evolution compounds or drifts. This is the same control worry Anthropic raised about Sakana's recursive-self-improvement lab (06-07).
• Discovery vs remix. Self-Revising Discovery Systems (06-08) formalizes the distinction between retrieval, search, and genuine discovery (inventing a concept not already in the toolkit) and gates accepted revisions by description length (one run: 25 of 388 proposals accepted, 6.4%). Most self-evolving agents only do retrieval and search.

Industry signal

Sakana AI launched a dedicated recursive-self-improvement lab (06-07), explicitly betting that self-improvement, not raw compute, is the next lever. Anthropic flagged the control risk. The research cluster above is the academic front of the same bet.

The "evolving environment" turn (2026-06-14)

One HuggingFace batch carried three papers sharing a single reframe: stop assuming the world is static. EvoArena/EvoMem makes progressive environment updates the eval unit and stores memory as patch histories; Evoflux evolves tool-workflow graphs at inference time to repair plans against changing tool catalogs; EvoBrowseComp auto-regenerates a contamination-free benchmark to keep pace with shifting world knowledge. The distinction from the 06-08 self-evolving cluster is subtle but real: those agents evolve themselves; these adapt to an environment that evolves underneath them. Three papers, one day, same blind spot named — the static-world assumption.

Related pages

• Scaling the Harness: the harness as a design object
• Code as Agent Harness
• Agent benchmarks · Agent memory · Tool calling
• LLM routing: the cheap-evolver/expensive-solver split is a routing decision

Four papers, one week: the unit of self-improvement is a verifiable callable artifact (2026-07-27)

The episodic-to-procedural thread on this page hardened into a default this week. Four papers, all routing self-improvement through a structured intermediate representation rather than learning from raw traces, and none of them arguing for the trace-based alternative any more:

1. Skill Self-Play (07-27), from a Qwen applications team. Names the dilemma cleanly: environment-bound self-evolution gets precise verification but narrow coverage, open-ended self-generation gets coverage but no reliable verifier, so misleading rewards pollute the loop. Its resolution is that a skill is a scope boundary that carries its own verifier, so breadth comes from routing across a growing skill library while rigour stays inside each skill. A proposer, a solver, and a skill controller co-evolve under RL. Code released.
2. MSCE, via DAIR.AI's weekly roundup in starred Gmail. Training-free memory-skill co-evolution with three governed levels: L1 grounded step traces, L2 reusable procedural policies, L3 declarative environmental cognition. L2 policies with positive estimated gain are crystallised into callable skill cards carrying evidence links, applicability boundaries, decision guidance, verification rules, and reliability estimates. Sparse terminal feedback is propagated through dense local self-reflections to produce evidence-calibrated trace values. Beats skill-augmented and memory-driven baselines on EvoAgentBench and LoCoMo with cross-domain transfer.
3. Teaching LLMs to Self-Evolve: Cultivating Core Meta-Skills with RL (2607.21971), Kurate weekly cs.LG #7.
4. Knowledge-Centric Self-Improvement (2607.19592), Kurate weekly cs.AI #4.

The shared claim, stated most sharply by MSCE: most memory systems retrieve past traces as passive context, so hard-won experience never becomes something the agent can directly execute. The unit of transfer has to be structured, verifiable, and callable. This is where Ctx2Skill (05-05), From Raw Experience to Skill Consumption (05-25), MUSE-AutoSkill (05-27), and SkillEvolBench (05-26) were heading since spring. It has arrived.

The threat none of the four addresses. Every one of these is a self-rewarding loop, and More Convincing, Not More Correct (07-26) showed one day earlier that a judge conditioned on a candidate answer scores plausibility rather than correctness: judge pass rate rose 0.72 to 0.94 while true accuracy stayed at 0.20, the exploited errors transferred across judge families and scales, and a strict three-judge ensemble still accepted 55% of hacked answers.

The four differ in exposure, and the difference is instructive. Skill-SP verifies inside a skill's scenario, which is closer to an environment check than to an LLM judge, so it has the strongest structural defence. MSCE crystallises L2 policies on "positive estimated gain" and does not say who estimates; if the model does, it is in precisely the configuration that produces the false-positive basin. None of the four runs the hidden-anchor audit, the held-out exact-match check applied outside the training loop, which costs one comparison and would immediately show whether the reported gains are real.

Open problem added: does a self-expanding skill library reach genuinely new territory, or does it saturate and refine what it already covers? Every paper in this cluster reports downstream benchmark gains; none reports library growth or coverage over time, and that curve is what distinguishes open-ended self-evolution from an elaborate curriculum.

Partially answered 2026-08-12. SkillZip is the first paper to examine the grown artifact rather than its downstream scores, and its premise is that the library is substantially compressible: the same requirement restated across branches, common action sequences copied rather than referenced. That is a redundancy measurement standing in for the coverage curve, and it points to the saturation branch. Still nobody plots growth against coverage over time. See the 2026-08-12 section at the top of this page.

2026-08-28: live self-evolution, and training the model to survive its own scaffold changing

Two additions that sit at opposite ends of this page's usual axis.

PILOT in the Loop (arXiv 2608.26530) moves self-improvement into the present tense. Every system on this page learns after the run ends, which means the lesson arrives after the run that generated it has already failed. PILOT's diagnosis of why existing architectures cannot do better is the sharpest part: single-agent self-correction puts execution and trajectory assessment in one context, so the judge shares all the confusions of the thing it is judging; subagent delegation separates them cleanly but the parent typically cannot reach into an active subagent, so oversight only lands on return, which on a long task is exactly too late. PILOT keeps the context separation and adds the missing channel. A supervisor watches the worker's trace as it streams, can redirect or abort mid-execution, and distils procedures and failure modes into reusable skills and memory during the run.

Results: first in five of six configurations, +9.8 points over counterpart harnesses on Terminal-Bench 2.0, +14.6 with GLM-5.1 and +12.4 with Kimi-K2.6 in the self-improvement setting, and the efficiency pair that matters most, mean output tokens down 42.9% and 47.4% with successful evaluations per million output tokens up 110.3% and 134.0%. That is a cost-per-success metric, which almost nothing on this page or the harness page has published. Read it carefully though: aborting doomed trajectories early is a refund, not a shorter successful path, and a supervisor that reads traces and emits short steering messages consumes many input tokens while producing few output tokens, so an output-token-only saving may be measuring a shift rather than a reduction.

This completes the offline/between-runs/live triple. AutoSaddler (08-26) learns offline from failure mini-batches, which is what makes its patches durable. Recuris (08-26) patches between runs from verified working state. PILOT patches during the run. The trade is untested: offline generalizes because each patch sees several failures, live arrives in time but derives from one trajectory, which is exactly the trajectory-specific repair fails to transfer failure AutoSaddler's ablation isolated. Offline versus live at matched budget is now the cheapest valuable experiment in this area.

Does it respect the admission rule? This page and the harness page record the rule as settled at five independent arrivals: bound the edit and gate the admission, or the optimizer overfits its most recent failure (DarwinX's preserve-and-extend contract, Ken Huang's measured-bounded-reversible pattern, Recuris's validation-gated local patches, and AutoSaddler twice over). PILOT distils into skills and memory rather than rewriting the loop, which is a bounded edit. Whether the distilled skills are gated on validation before reuse is the detail that decides if live self-evolution is inside the rule, and the abstract does not say. Live patching is where the rule is hardest to honour, since there is no time to validate.

TaoLive Harness-Aware Training (arXiv 2608.15763, Alibaba) inverts the page's premise. Rather than the agent evolving its scaffold, the model is trained to tolerate the scaffold being evolved by humans. Harness-State Augmentation perturbs skill identifiers and content, tool schemas, prompt structures and Hook functions during training so the model learns to read a harness instead of memorizing one. Three stages: HSA-SFT, then General On-Policy Distillation to restore generalization damaged by SFT, then HSA-RL in augmented environments. The key negative result: Fixed-Harness SFT drops IFEval 7.7 points below the base model, and HAT does not (83.5). Specializing a compact model to one production scaffold makes it worse at instructions generally, which is a warning to a large number of teams.

Deployed at Taobao Live: P50 3.4s, P95 8.1s on a single NVIDIA H20, with positive online A/B results on GMV and item-page views. This page has had almost no deployed-latency data points, and this is the first with a P95 and a revenue metric.

WikiSkill (arXiv 2608.27454) adds the finding that should most change how this page thinks about self-improvement loops: skills evolved by other models can outperform self-evolved skills. If that survives the obvious confound (a stronger author simply writes better procedures, which would make it a distillation result), then self-improvement is not obviously the optimal architecture, because skill authorship becomes a separable and purchasable step. It also finds larger models benefit more from evolved skills, against the natural prior that scaffolding helps weak models most and washes out at the frontier, and that skills transfer across model families.

What is still missing, for a fifth consecutive dense day. No paper here publishes the search or maintenance cost. And Thinkingbox (08-25) showed the strongest model collapsing from 65.36% pass@1 to 25.25% pass^20 on stateful business workflows; PILOT reports first-attempt ranks on Terminal-Bench 2.0, a stateful benchmark of the same family. The pass^k curve for a self-improving agent remains the most conspicuous cheap missing measurement.