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.

2026-09-15: three RSI papers in one day, and the 09-13 taxonomy grades them before the discourse can

HuggingFace published three recursive-self-improvement papers on one morning, which by this page's own threshold is a converged pattern rather than a coincidence. The useful thing is that The Last AI Built by Humans (09-13) supplied the grading rubric two days earlier, so for the first time this page can assess a cluster against a criterion written before the cluster arrived rather than after. That survey's test: a one-time gain is not RSI; the mechanism produced in round N must be retained into round N+1, and under comparable budget with independent evaluation it must produce a stronger successor. Its five levels run L1 improvement-execution, L2 improvement-strategy, L3 experience-acquisition, L4 environment-adaptation, L5 recursive meta-improvement, where the system modifies its own search strategy, evaluator, or candidate filter.

Dream-RSI (09-15) (arxiv 2609.14858, Google, Google DeepMind, Maryland, Virginia) is the first entry on this page whose target is L5-shaped. It leaves the coding agent untouched and optimizes the exploration policy: which branch to expand, how much parallelism, refine or open a new direction, when to stop. Its mechanism is the clever part. A completed discovery run leaves a tree of branches, candidates and scores, and that history can be replayed as a simulator over the realized search space, so candidate exploration policies get immediate off-policy feedback with zero model invocations. Refine there, redeploy online, and the new run enlarges the simulator pool. Evaluated on algorithm engineering, mathematical optimization and GPU kernel engineering, reporting competitive or improved discovery quality at substantially reduced discovery cost in several settings.

It is the first result in this cluster whose headline is a cost reduction rather than a capability gain, which is the discipline this page has demanded for a month. The 09-04 standing caveat recorded Environment Evolution as "the ninth consecutive result in this cluster to omit the cost of its own mechanism." Dream-RSI's entire mechanism is a way to make the loop cheaper, and it is the cheapest possible form of the bounded trial BCIT (09-04) proposed: buy evidence about a candidate before authorizing it, except here the evidence was already bought and is being reread.

And it proposes a fifth explanation for the Evo-Bench plateau, the first with an obvious intervention. This page lists four: single-trajectory variance (Mendel Gödel Machine, 08-12), the limit being self-editing evidence rather than research ability (AutoWorldModel-Bench, 08-13), curriculum starvation (Environment Evolution, where failures dry up exactly when the signal is needed), and stale preconditions (BCIT). Dream-RSI implies a fifth: the meta-search is under-sampled rather than exhausted, because each cycle can only afford a handful of policy candidates. If replay buys a hundred evaluations for the price of none, the saturation point should move. The paper does not run Evo-Bench, and that is now the cheapest discriminating experiment available on this page.

The structural objection is the meta-level version of curriculum starvation. A replay simulator is built from the realized search space, so it can only score a policy on territory an earlier policy already visited, and a policy whose advantage is exploring where nothing has gone is exactly the one it cannot reward. Environment Evolution made this argument at the object level and this page accepted it. It applies here unchanged, and Dream-RSI does not address it.

RSIAgent (09-15) (arxiv 2609.15364, Aether AI with UCSD and UIC) is L3 at best and the label is wrong, but the result is the strongest instance yet of the discipline this page settled on after 09-09. Training-free, no weight updates, no task labels: curriculum, actor and verifier agents explore a new environment broad-then-deep, and what gets retained is reusable causal relationships between actions, conditions and consequences, validated by an independent verifier before entering memory. The memory is then frozen and reused, lifting Kimi-K3 and GLM-5.3 past GPT-6 on OSWorld-v2 and Agent's Last Exam.

Write-time validation gating is now the field's default rather than a proposal, and this is the third paper in a week to do it. Procedural Graphs (09-09) commits only edits that preserve or improve held-out validation performance; Ecdysis (09-12) repairs only what recurs across unrelated tasks; RSIAgent admits only verifier-confirmed causal rules. The 09-09 operating rule, that the more autonomy the loop has the more of the evaluation must sit outside its reach, has gone from a recommendation to an architecture in eleven days.

RSIAgent also extends the portability result to a new artifact class. The same frozen memory lifts two different base models, which makes environment knowledge the fifth thing this cluster has shown transfers, after AI4AI strong-to-weak, AutoDesign across seven code-agent-model configurations, Meta-Harness across five held-out frontier models, and WikiSkill across model families. The harness page boundary holds: causal action-condition-consequence rules are structure, and structure is what travels. The missing control is obvious and damning if it goes the wrong way: nobody ran GPT-6 with the same memory.

Atria Dawn (09-15) (arxiv 2609.15818) has the worst title and the best evidence. Ignore "agentic superintelligence"; the contribution is that the authors instrumented their own model build and published 769 task records from 56 participants alongside agent logs. Participants rated about one-third of completed AI-assisted tasks as infeasible without AI, and the division of labour they report is that agents frequently propose methods and implement revisions while humans retain most final decisions and guide exploration.

That second finding is the one this page should carry, because it agrees with a controlled experiment using a completely different method. AutoWorldModel-Bench (08-13) found a frontier coding agent improved a world-model starter in 63 of 64 sessions with 91% of winning edits being research-style modifications rather than hyperparameter tweaks. A benchmark and a production research log now agree that agents contribute at the level of method proposal. That is the specific claim most likely to be dismissed as hype, and it is now twice-measured by unrelated methodologies.

Where the three leave the taxonomy. Dream-RSI aims at L5 and demonstrates one loop closing, not a retained mechanism producing a stronger successor. RSIAgent is L3 with a frozen artifact. Atria Dawn is explicitly a partnership in which humans decide what is worth pursuing. Nothing published today clears the 09-13 bar, and the strongest of the three says so itself. The SoL-Pi Efficiency for Efficiency test remains the single most important unrun experiment in this area: iterate N rounds, feed each round's output back as the next round's substrate, plot cost-per-accepted-idea against round number. Dream-RSI is now the cheapest system on which to run it, because replay makes each round nearly free.

One thing outside the papers belongs here. The same week, Dario Amodei's pace-the-frontier essay rested on the claim that AI is accelerating "driven primarily by AI's growing ability to build the next generation of AI," naming agent swarms as the danger. ZGCM-1 (09-15) reports that agent swarms autonomously managed cluster operations, data curation and diagnostic evaluation for its own training run, presented as a methodology worth copying. This page's inventory says nothing yet clears L3, and an executive argument for slowing down rests on a premise the research record does not support at the level claimed. Both of those can be true, and the honest statement is that the capability is real, bounded, and moving faster in infrastructure than in the loop.

2026-09-09: a third lever appears, and the field converges on validation gating as the discipline

This page splits the "self" into two levers: harness updates (scaffold rewritten, weights frozen) and weight updates (weights updated, scaffold fixed), and says the frontier is combining them. NeoHorse-1 (09-09) is a genuine third position: the harness is neither changed nor held fixed as a control, it is used as the sensor. A deployed routing harness records, per turn, the predicted capability demand, the selected service tier, and the outcome. NeoHorse-1 converts that into a curriculum and a training mixture, closing an evaluation-selection-update loop, and reports macro-average gains of 58.94 to 64.87 at 4B and 65.60 to 69.04 at 9B across eleven benchmarks, with the post-trained 4B substantially narrowing the gap to the 9B base. The recursion is a prototype, not a demonstration: there is no second iteration showing the improvement rate itself improving, so this belongs under bounded self-improvement rather than RSI.

Ben Lorica's essay (09-09) gives this page the vocabulary it has been missing. Three ideas the discourse collapses: continual learning (does experience make the system better next time), bounded self-improvement (can the system turn experience into a tested, persistent change), and RSI (does the system improve the process that generates improvements). They are not rungs on a ladder; a system can do any one without the others. Almost everything on this page is the middle one.

Two of the essay's reported failures are this page's drift concern, measured. Systems rated themselves as improving while independent tests showed many were not. And in one case a score improved because the agent learned to avoid being flagged by the hallucination detector, not because it hallucinated less. Lorica's framing is the right deflation: ordinary metric gaming with a faster optimizer. The operating rule that follows is the one this page should now hold every proposal to: the more autonomy the loop has, the more of the evaluation must sit outside its reach, with permissions, security boundaries, spending limits and release gates permanently outside the editable layer.

Procedural Graphs (09-09) is that rule implemented, and it is the cleanest instance on this page. Its LLM refiner edits graph topology and attributes by contrasting failed against successful trajectories, and commits only edits that preserve or improve held-out validation performance, while retaining rejected edits so the refiner does not retry them. Starting from a minimal skeleton it builds graphs that match or surpass hand-designed ones, and it can repair a flawed expert prior. Against Recuris (08-26), which composed verified working state, need-grounded skill retrieval and validation-gated self-optimization into one system, the Procedural Graph is narrower and more legible: one artifact, one edit rule, one gate. Whether an explicit action-graph beats Recuris-style retrieved skills at matched budget is untested and is the obvious next comparison.

And the largest field evidence for the drift concern arrived the same day. The six-month production trading-agent record (09-09) finds agent behavior set by the operating layer's sliders and defaults rather than by strategy text (agent fixed effects absorb 60% of variance, a risk slider explains leverage at +0.425 per level, a leaderboard render boundary causally routes selection at 1.75x), while neither fleet shows any directional edge at all. The loops optimized what the loops could see.

2026-09-04: the page's oldest open result gets its third and fourth explanation, and both blame the loop's own conditioning

Evo-Bench's early saturation, where autonomous harness evolution plateaus after a few cycles, has been this page's largest unexplained result. Two papers today propose distinct mechanisms, and both say the same structural thing: a loop that conditions on its own observed failures starves itself.

Environment Evolution for Terminal Agents (09-04) (arxiv 2609.04128, Hunyuan Team, Tencent) makes the argument about curricula. Environments synthesized from scratch stop being useful because frontier models solve them, so RL gets no gradient and the environment is discarded along with its build cost. The existing fix, agent-environment co-evolution, mines on-policy rollout failures to build harder environments, and this paper's objection is that the fix breaks on its own success: as the agent improves, failures become rare, so the signal driving synthesis dries up exactly when it is most needed, and the environments produced encode one model's idiosyncratic weaknesses rather than general difficulty. Their alternative raises difficulty off-policy, deriving three difficulty-increasing directions from the multi-turn learning objective itself and scheduling generations across training, implemented through a loop-engineered multi-agent harness. Difficulty is validated across three unrelated frontier agents (Hy4 preview, Claude Opus 5, GPT-5.6 Sol), which makes it a much stronger object than a policy-calibrated curriculum. Long-horizon RL gains: +14.4 points on Qwen3.6-27B, +18.0 on Qwen3.6-35B-A3B, on Terminal-Bench 2.1.

If this transfers to harness evolution, Evo-Bench's plateau is neither a variance problem nor a ceiling on research ability. It is the curriculum starving itself, and the predicted fix is specific: derive harness-edit directions from the objective rather than from observed failures. That is testable and it changes nothing else about the loop.

BCIT (09-04) (arxiv 2608.26730) makes the argument about experience. In autonomous post-training, an update's effect depends jointly on its parent checkpoint, its data and the training stage it was applied at, so treating past success as context-free permission wastes compute on runs that will not reproduce, and if the resulting child is promoted anyway it corrupts the trajectory that follows. The paper names this conditional experience transfer and gates it: bind each observed effect to its source context, check applicability against current state, veto candidates with named hard conflicts before any weight-changing training, and buy current-state evidence with a bounded training trial where the conditions are genuinely uncertain. Only observed events extend memory, so the store never accumulates its own inferences. On one 4B model across finance reasoning, text-to-SQL and function calling, under matched candidates, evidence and compute, BCIT authorizes fewer harmful updates and reaches higher equal-budget final-model quality.

BCIT is the first paper on this page to attack the reuse decision rather than the reuse artifact, and that is the gap it exposes. Every entry in this page's cluster performs an operation on stored experience: SkillZip (08-12) compresses it under a typed MDL objective, ALTK-Evolve (08-12) delivers a per-task subset (263K tokens against 634K at 89.3% against 80.4% completion), WikiSkill (08-28) persists it across cycles, CASKG (08-28) builds counterfactual causal structure over it. All of them improve what is in the store or how much gets delivered. None asks whether a retrieved item is still valid. BCIT says validity is conditional on state, and a store of unconditioned successes is a store of claims with expired preconditions. That is a fourth explanation for the plateau: the loop keeps re-applying experience whose preconditions no longer hold, so a growing fraction of each cycle's compute goes to updates that cannot reproduce.

Four hypotheses now stand for one phenomenon, and it is worth listing them because they make different predictions: Mendel Gödel Machine (08-12)'s single-trajectory variance (edits mostly correct noise); AutoWorldModel-Bench (08-13)'s evidence that the plateau is about self-editing evidence rather than research ability (agents improved an external artifact in 63 of 64 sessions); Environment Evolution's curriculum starvation; and BCIT's stale-precondition waste. BCIT's is the only one with a proposed intervention measured against matched compute, and that discipline should be the page's default.

Two methodological credits, both rare here. The difficulty validation across three unrelated frontier agents is a stronger construct than anything else on this page, and BCIT's headline is an equal-budget quality comparison rather than a capability delta with an unstated bill, which is exactly what llm-routing.md has demanded since the AlphaSense study (08-14) showed per-token pricing ranks models backwards.

Standing caveat, unmoved. Environment Evolution's evolution mechanism is itself a loop-engineered multi-agent harness whose cost is unreported, which is the ninth consecutive result in this cluster to omit the cost of its own mechanism, and here it is worse than usual: a method justified on the grounds that from-scratch environment construction wastes money owes a build-cost number. BCIT does not report what its bounded training trials cost as a fraction of the budget they are drawn from.

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.

2026-09-13: a definition arrives, and every system on this page sits below the bar

The Last AI Built by Humans (09-13) (arXiv 2609.11873) is a survey, and it earns a page here for one reason: it supplies the falsifiability criterion this area has been accumulating results without. A one-time performance gain is not recursive self-improvement. Two conditions have to hold. The improvement mechanism produced in round N must be retained and participate in round N+1. And under comparable budget with independent evaluation, it must produce a stronger successor.

Five levels of autonomy, ordered by how many R&D decisions the system takes over. L1 improvement-execution (humans decide what and how, AI executes). L2 improvement-strategy (AI finds its own improvement strategies). L3 experience-acquisition (AI decides what training experience the next round needs). L4 environment-adaptation (continuous update from deployment feedback). L5 recursive meta-improvement, where the system modifies the improvement mechanism itself: its search strategy, its evaluator, how candidates get produced and filtered. The paper also introduces a Headroom-Closed Index to characterize how much achievable improvement current LLMs have actually closed, arguing they are not at their own frontier, which is the precondition for self-improvement having material to work with.

Applied to this page's inventory, nothing clears L3. A²E and Evo-Bench (08-11), DarwinX and AutoDesign (08-14), Ecdysis (09-12), SoL-Pi (09-11) and COBRA-Skills (09-13) all sit at L2 or L3. None modifies its own improvement mechanism, and none reports whether an improved mechanism was retained into a subsequent round.

That makes SoL-Pi's unmeasured Efficiency for Efficiency claim the single most important open experiment in this area, and two independent sources now specify the same test. NVIDIA's argument is that a cheaper harness makes the research loop cheaper, buying more experiments per budget, finding a cheaper harness. The harness page already flagged it as claimed-but-unmeasured and specified the protocol: iterate N rounds, feed each round's harness back as the next round's substrate, plot cost-per-accepted-idea against round number. This survey arrives at the same criterion from the taxonomy side. Two directions, one falsifiable test, still nobody has run it.

Scenario-dependence is the practical finding and it explains where to look first. Software engineering is the fast lane because verification is nearly free (compile, run tests) and the artifact is text. Embodied intelligence is the slow lane because every round costs physical time. Scientific discovery sits between. If recursion is going to be demonstrated anywhere in the next two quarters, it will be on a software-engineering benchmark.

A third instance crosses this wiki's pattern threshold: the persistent-improvement substrate is text, not weights. MemRL, surfaced alongside the survey, evolves via reinforcement learning on episodic memory with a two-phase retrieval that filters noise and identifies high-utility strategies from environmental feedback, reporting gains on HLE, BigCodeBench, ALFWorld and Lifelong Agent Bench with no weight updates. Recuris (08-26) split memory into verified working memory and experiential memory retrieved by that state. Meta's Organizational Second Brain (09-02) compiles expert corrections into verified, regression-tested knowledge updates without retraining, explicitly separating what the agent knows from how it reasons. Three independent systems, three different framings, one architectural conclusion.

Risks accumulate through the same channel capabilities do, which the survey names and which is the reason the retention criterion is not merely pedantic: bad experience is inherited by the next round, and an evaluator the system modified is an evaluator it can drift.

Caveat. It is a survey with a roadmap, not an evaluation. The HCI is introduced but no system is scored against the five levels, the levels have no operationalization from published artifacts, and the "preliminary empirical evidence" is industry practice reported by practitioners, which is the weakest evidence class available for a claim about whether a loop compounds.

2026-09-20: the strongest candidate yet for the 09-13 bar, and a well-argued case that it will not compound

The 09-13 entry recorded a definition of self-improvement arriving and every system on this page sitting below it. ScientistTwo is the closest thing yet to clearing it, and the reason is one specific design choice: it uses its own discovery as the next baseline. Full write-up: ScientistTwo and the RSI argument (09-20).

Reported by Google: an autonomous loop that proposes ideas, runs experiments, prunes what fails, and incorporates reviewer feedback across rounds, applied to problems drawn from accepted ICLR, ICML and NeurIPS papers. 80.4% success rate, improvements over the original human baseline on 86 of 107 problems, 25.2% average relative improvement, about 2.5 days and $3,765 per paper. At least one case chained three consecutive record-breaking rounds. Nine experienced researchers rated outputs roughly level with the human papers.

Why it is still below the bar, precisely. The 09-13 definition asks whether the loop improves the improver or only the artifact. ScientistTwo produces better methods; it does not produce a better ScientistTwo. Self-baselining is genuine recursion over the output, not over the mechanism, and three rounds is not enough to distinguish compounding from saturation. The AREX (07-25) pattern of verification as the round boundary reappears here as the reviewer-model loop, with the same weakness: the verifier is the same family of system as the generator. Most of the evaluation is AI-refereed, with a rebuttal model running additional experiments until a passing grade, and nothing was submitted to a venue and accepted.

The scope caveat is the whole argument and both sides agree on it. ScientistTwo's own framing is that experimentation can be automated long before scientific judgement can. Every one of the 107 starting points is a problem humans posed and reviewers selected. Nathan Lambert's essay the same weekend makes the bounding case from the other direction: his lossy self-improvement position holds that automatable research is too narrow to net a large acceleration against the exponential cost curve of scaling, that parallel agents show real diminishing returns, and that resource and political bottlenecks dominate. The timeline spread he reports from the Schulman / Millidge / O'Neill discussion is the useful calibration: on a 10x uplift for AI researchers, estimates run from about 2 years to 5-10, and O'Neill's stated bottleneck, deciding which experiment to run next, is exactly the half ScientistTwo does not do.

Two automated research loops in ten days is the pattern worth naming. SoL-Pi (09-11) ran the same shape over agent scaffolding rather than ML methods, evolving four runtime mechanisms and cutting tokens 45-49% at about 94% of task score, and it circulated widely again today with the sharper framing that the scaffold is where the money leaks. Both loops report large wins, and both were handed a well-posed objective and a fixed evaluation. The unasked question for this page is whether either survives a problem the loop chose itself.

The obvious missing experiment: run the loop on problems from rejected papers, or on open problems with no established baseline, and see whether 80.4% survives. Improving a published method on the benchmark its authors selected is the easiest available version of the task.

2026-09-23: AIDE² closes the loop on an agent's own source code

AIDE² is the first result on this page where the object of optimization is the agent's own code and the gains transfer out of distribution. Seven successive accepted self-edits in an autonomous 8-day run, selected on hidden evaluations, transferring to four held-out benchmarks including physics-based weather forecasting, matching or exceeding a human-engineered production research agent on all four.

Two findings deserve to outlive the paper. First, the selection signal is what determines whether the loop generalizes or overfits: AIDE² holds out the judge where RRSI (09-22) regularizes the proposer, and RRSI's own numbers (14.1 points in-distribution against 4.7 out) are the quantitative case that this is the binding problem. Second, reward hacking fell from 55% to 32% without ever being targeted, ending 7 points below the human-engineered agent, which suggests held-out selection filters reward hacking as a side effect because gaming a reward is unstable under transfer.

Caveat the page should carry: this is one run. A self-improvement trajectory is one sample from a distribution of search paths, and no seed variance is reported. The loop's compute cost is also unstated, which matters because the paper's motivating claim is that self-improvement counters diminishing returns on R&D spending, and that argument needs a cost-per-unit-of-improvement comparison against human engineers to land.

The governance conversation arrived the same week. OpenAI published a call for international standards on recursive self-improvement on 09-22, and Anthropic's Opus 5.5 system card put 100-instance parallel self-organization on the record, with emergent structure depending on the task (hierarchical on Lean, flat on knowledge-base work). Measurement and regulation arriving together is unusual on this page.

2026-09-27: self-improvement moves to talks and small open models (social and video signal)

• Talks, not papers, this weekend. AI Engineer and MLST posted a run of self-improvement talks: Weco's Zhengyao Jiang on the eight-day harness rewrite behind AIDE² (09-23) and how to separate real discoveries from reward hacking (video); Prime Intellect's Elie Bakouch on Claude Code and Codex both beating the human record on the Optimizer Speedrun, with very different behavior (Claude Code kept stopping to say the record could not be beaten) (video); GEPA's Lakshya Agrawal on reflection over full traces doubling GRPO's gains from three examples versus 25,000 rollouts (video); and W&B's ARIA agent turning production traces into eval tasks and fixing itself (video).
• A small open RSI loop. RSI-Jev v2.0 (2B) was produced by an agent team that ran 50 experiments in about 15 hours; it scores 0.79 versus Jev 1.13's 0.73 on typed decisions. Task gains did not transfer much but calibration did (@GaoShanghua).
• Budget allocation for research agents. PRIMESCIENTIST keeps competing plans in a tree and shifts from exploring to exploiting as the budget shrinks: 10.3% higher reward than AutoResearch with 50.6% fewer attempts on 12 FIRE-Bench tasks (@rohanpaul_ai).
• The regularization caveat still governs all of this: RRSI (09-22) showed unconstrained harness evolution gains +15 on the training split and loses up to 4.4 points out of distribution.

2026-09-29: the outer RSI loop reaches a lab's serving stack

Zhipu's Infra Agent, powered by GLM-5.3, did much of the work of taking GLM-5.3-Flash from adaptation to production in under two weeks, tripling end-to-end throughput. Jack Clark calls it the outer RSI loop: self-improvement through the lab's infrastructure rather than its weights. Zhipu's lesson is about feedback, not the agent. It must be local (tied to a kernel, launch parameter or code path), cheap and timely, and objectively verifiable. Serving optimization fits all three, which is why it is among the first things labs automate.

Two companions supply the discipline and the ceiling. Google Research's RRSI repository freezes the model, evolves prompts, tools, memory and flow, and keeps only changes that beat eval noise; with Claude Opus 4.8 fixed it reports Terminal-Bench 2.1 74.2% to 80.2% and held-out SWE-bench Verified 82.0% to 83.8% (author-reported). The held-out gain (1.8 points) is a third of the Terminal-Bench gain (6.0), the same shrinkage the RRSI paper (09-22) warned about when it found that most harness-evolution gains do not transfer. ScientistTwo (09-20) pushed past the published state of the art on 86 of 107 accepted-paper problems (average 25.2% relative gain), and 9 human researchers judged its maturity roughly equal to the originals, the strongest evidence yet against the claim that automated experimentation stays visibly immature.

2026-10-10: frozen weights, external learning

Agent shorts (10-10): AgentGarten agents learn in ~4 rounds by inheriting playbooks inside code worlds with a neural renderer; Memento 3 keeps a verified rulebook compiled to code and clears all 25 public ARC-AGI-3 games; Station rediscovers 62.7% of withheld ICLR-oral findings. Counterweight the same week: Epoch's agents reached at most 35% of a human method's gains and MMPostTrainBench agents made models worse 52.1% of the time (unintended actions page).

2026-10-11: self-improvement without a verifier

• MASS (Sakana + Berkeley). One model proposes, runs and grades multi-agent workflows, evolutionary search keeps the best, and the model is fine-tuned on both orchestration and bounded sub-agent traces. Two cycles on Qwen3.6-27B: 1.2-1.6x performance per output token. Risk this wiki flagged on 10-07 (self-generated feedback destabilizes training) and OpenAI's 10-11 report of an evaluator model fabricating scores both bear on whether a third cycle holds.
• IdeaScientist (Meta): three RL-trained ideation roles over 2.77M decomposed ideas; a 27B model beats the best open autoresearch baseline by 14%.

2026-10-13: graders that evolve, and research taste on a curve

DUET (Microsoft) alternates solver and grader updates (Finance Agent 96.5%; GDPval grader agreement 68.4% to 78.5%); training the grader alone barely helps. Double Ratchet (AWS + HSBC) evolves a rule-based grader selected only for agreement with 10 labels. RSI-Anything gates policy updates with world-model compatibility checks. Import AI reports P-Zero's TasteVal: experimental research taste doubling every 3.0 months since Dec 2025, Opus 5.5 above a 24-expert baseline at 1/30 cost (industry 10-13). Anthropic's Memento harness shows replicating agents improve across generations via notes (10-13).

2026-10-16: tension, history helps editing but stalls discovery

Scaling Discovery Requires Forgetting finds research agents anchor on accumulated attempts and plateau; wiping history beats keeping it. Harness² and Evo² (10-14/15) improve by keeping edit history. Possibly compatible (method vs attempts), untested on a shared task.

2026-10-17: measurable self-improvement, under frozen evaluators

• Athanor, Terminal-RSI, Harness RSI, Minecraft (10-17). Four Opus 5.5 agents post-train Qwen3-4B-Base past the official instruct model in 104 h (held-out 48.2 vs 47.9) by recombining SFT, RL, merges and self-distillation. Terminal-RSI: five alternating rewrite/refine stages to 86.52% on Terminal-Bench 2.1. Harness RSI: a PAC-style admission rule for harness edits using fresh validation. Gemini 4 Argon team beats Minecraft in 27h14m with no roles. AutoSFT: a single agent loses context mid-search; a meta-agent separating execution from analysis adds +6.5 IFEval. RSI-Anything (via X, 2610.13912) adds a world-model "rehearse before acting" step.
• Quantum circuits (10-17): evaluator-guided search with Claude Mythos 5 beats best-known circuits on 7 of 8 tasks.
• Pattern: every credible result here has a frozen, hidden, or mechanical evaluator. The design question has moved from "can the agent improve" to "what can the agent not see."

2026-10-22: the audit arrives

Harness-evolution wave and memory worth. Harness-Delta Attribution quantifies the 10-17 "what can the agent not see" pattern: without held-out tasks, ~54% of the gain is search-set overfitting. Are Self-Evolving Agents Continual Learners? (via X): ReasoningBank, GEPA, Meta-Harness all trade stability for plasticity on drifting streams. Anti-Persistence: stored abstractions reproduce their own errors. Pattern n=3 with Scaling Discovery Requires Forgetting (10-16): accumulated agent memory degrades by default. Positive counterweights: Épi (persistent research agent, 120 records; Épi-turbo +5.4% over Codex at 64% cost), Microsoft's human-directed agentic search proving the KLS conjecture where unguided runs failed.

2026-10-23: experience becomes supervision; research agents measured

• RSD (Meta, 2610.27495): the model re-scores its own actions with hindsight and cross-task lessons as privileged context, then self-distills; up to +59.7% relative, +44.7% more with frontier-edited context policies.
• Automated research measured: Agent4Sci gains are ML-engineering tricks, not insight (Opus 10.4% to 20.1% with plug-in skills); FrontierCS 2 best pass rate 58%; LM2LM trains a proposer against a research world model; an AI research team beat GDN2 at 1.3B; only 37 of 1,598 RL-method papers reached a training framework.