Self-evolving systems may update model weights, prompts, skills, memory, workflows, training environments, optimizers, or the rules that perform those updates. Their deployment contract has three properties.
The write target is the object that changes.
The update clock determines when an update can affect later work.
The acceptance process determines whether an update replaces the current version.
System boundary: what changes and how updates are accepted
A write target is the part of the system that an update changes. The change may affect the next attempt, an unrelated task, or a future deployment.
The system boundary extends beyond the deployed agent. Model and harness state determine agent behavior, while optimizer and environment state are about the learning process. Changing the optimizer or environment may help produce a better agent. Evaluation must determine whether the resulting agent performs better.
The acceptance authority is the component with final permission to replace retained state. Evaluators provide evidence.
Held-out evaluation. Tests a candidate on a separate set of cases that was not used to develop the candidate.
Regression suite. Reruns cases the system previously passed to detect regression.
Deterministic verifier. Applies fixed, machine-readable rules that give the same result for the same input.
Independent grader. A human grader or LLM judge scores open-ended output against an explicit rubric.
The acceptance gate uses the evaluation results to decide whether a proposed candidate (model, harness, optimizer, or environment) should replace the current version.
Four update clocks
An update clock specifies when the system changes a write target. The timing determines what evidence is available and which work can benefit first.
A Survey of Self-Evolving Agents (2025) groups evolution into two categories. Intra-test-time evolution happens during a task, while inter-test-time evolution happens afterward. The four clocks divide those categories further.
But timing does not determine retention. Live-SWE-agent adds executable scripts during an issue-solving loop, reuses or revises them in later steps, and discards the evolved agent when the task ends. Test-Time Tool Evolution (2026) also synthesizes tools during problem solving and registers validated tools for later problems. Similar clocks can have different retention horizons.
Four update clocks follow the same sequence. S_t is the state at update step t, including the model, harness, optimizer, and environment. The system uses S_t to produce output y_t, then receives feedback f_t, such as a test result, reward, error, or user response. An updater uses y_t and f_t to propose candidate state S*. A gate accepts S* as S_(t+1) or keeps S_t. Best-of-k sampling and longer repair conversations can improve y_t without changing S_t. Later work uses the accepted update.
Test-time training: how long changes last
In the usual machine-learning workflow, parameter training stops before evaluation. Test-time training continues while the model processes evaluation inputs or real requests. “Test time” refers to the timing of parameter optimization.
Test-time training and self-improvement answer different questions.
Test-time training: When does learning happen? During evaluation or use.
Self-improvement: Does the resulting change improve later work?
Test-time training uses the current task or its feedback to update model weights, adapter weights, or temporary parameters that store information while the model processes one token sequence. A coding model can write a solution, run tests, and use a failure to adjust parameters before its next attempt.
Updated parameters may be reset after one token sequence, reused across attempts on one task, or kept across many training batches. Using the updated parameters in later work makes the process self-evolution. Evaluation must show better performance to establish self-improvement. Strictly speaking, changes to prompts, memory, tools, or executable harness code during evaluation are test-time adaptation or evolution, not test-time training.
Fast Weight Attention (2026) provides a token-level example of a within-sequence lifetime. At token t, the fast memory tries to predict an internal representation of that token using information from earlier tokens. After token t arrives, the prediction error updates the memory used to predict token t+1. The paper calls this a shifted pairing because it pairs the prefix representation at position t-1 with the target at position t. A conventional same-step pairing updates memory by pairing token t‘s key vector with its value vector.
Update timing is not coupled with type of state that changes. TTRL (2025) updates model parameters from unlabeled test data using majority-vote pseudo-labels. Learning What to Remember (2026) uses context distillation to decide which information from earlier tokens is stored in temporary model weights for use later in the sequence. Test-Time Tool Evolution (2026) changes executable tools instead of model weights. Tool and harness changes can share the test-time clock without being test-time training.
Model state: how feedback changes weights
Test-Time Reinforcement Learning (TTRL, 2025). It samples several answers to each unlabeled test question and uses the majority answer as a reward. A confidently wrong majority can reinforce the error.
Self-Adapting LLMs (SEAL, 2025). The model generates synthetic training data or instructions called a self-edit. An external loop uses the self-edit to fine-tune a LoRA adapter. The loop evaluates the adapted model and rewards proposals that improve its task score.
Test-time Learning on Open Problems (ThetaEvolve, 2025). ThetaEvolve adds weight updates to an AlphaEvolve-style program search. Verified program rewards train the proposal model, so later proposals reflect strategies found during search.
Self-Distillation Fine-Tuning (SDFT, 2026). A teacher copy sees an expert example and assigns probabilities to the possible next tokens for every student-generated prefix. Training moves the student’s probabilities toward the teacher’s.
Self-Distillation Policy Optimization (SDPO, 2026). SDPO uses two copies of the same model. The deployed student generates the original response without feedback. The teacher sees a verified answer or feedback added afterward, then provides token distributions for training the student.
On-Policy Distillation Evolver (OPD-Evolver, 2026). Its external memory stores past trajectories, warnings/heuristics, reusable skills, and tool templates outside the model weights. For each task, the system retrieves relevant records, uses them during execution, and updates its external memory afterward without changing model weights. Across multiple tasks, a slower training process updates the model weights from the recorded outcomes.
All six methods update trainable parameters that later work uses. SEAL updates a LoRA adapter, and the other methods update policy- or proposal-model weights. Four dimensions distinguish their updates. The update clock says when a change becomes active. The update target identifies the weights or adapter that change. Feedback identifies information unavailable during the student’s original rollout. The objective measures average accuracy, performance on earlier tasks after learning new ones, or discovery within a fixed attempt budget.
SDPO: dense supervision from one trajectory
Group Relative Policy Optimization (GRPO) compares several rollouts for the same task. But a request in production may yield only one trajectory, so GRPO cannot be used as a relative reward cannot be computed. Even with multiple trajectories, GRPO’s relative advantages are zero when all sampled answers receive the same reward, like when all answers succeed or all fail.
Reinforcement Learning via Self-Distillation (2026) introduced Self-Distillation Policy Optimization (SDPO). At each token position, the student sees the request and the response prefix generated so far. A teacher copy of the same model sees a verified answer, later user feedback, or a successful related rollout. After the response is complete, SDPO updates the student’s weights from the teacher’s token probabilities.
The teacher does not generate another full response. At token position t, the student predicts the next token from the request and original response prefix y_<t>. The teacher sees the same request and response prefix, along with feedback received after the original response. It then produces a next-token distribution. The teacher’s access to evidence that student lacked can change the next-token probabilities, creating the signal used to train the student. SDPO compares the student’s and teacher’s next-token distributions at each token position. A response with T tokens contributes T position-specific loss terms. The loss does not compare rewards across several rollouts.
For example, let’s say a user requests a yes-or-no answer, but the assistant writes several sentences. The user’s next message says the answer should contain only yes or no. During training, that complaint conditions the distribution for every prefix of the original response.
The original SDPO paper conditions the teacher on environment feedback, such as runtime errors, or on successful answers from other rollouts. Aligning Language Models from User Interactions (2026) extends SDPO to implicit feedback in the user’s next message. Its general-alignment experiments use logged WildChat and WildFeedback conversations for offline training, and its online personalization experiments use simulated users.
Production SDPO: delayed traces and policy lag
In the original SDPO paper, the training loop collects fresh samples from the current model before each update. Production feedback may arrive after other batches produce a newer model. The delayed response came from an earlier version, but the trainer updates the newer one.
Trajectory’s June 2026 field report describes an off-policy version for delayed feedback. It applies PPO-style ratio clipping so rare tokens cannot dominate an update, then clips each token’s advantage to reduce variance across runs. The experiments used Tau-Retail and APEX-Agents with one rollout per task and traces generated by an older policy version. The authors had not yet tested the method on live production traces.
SDPO can turn later feedback about a production response into dense training evidence without generating more attempts. The resulting weight update remains hard to audit. Unlike prompt diff that shows the new rule, a weight diff does not show which behaviors changed. Customer-defined evaluation and approval determine whether the checkpoint may replace the deployed one. A credible production loop needs source trajectories, policy versions, teacher inputs, optimizer settings, checkpoint hashes, regression results, and a rollback path.
Continual learning: plasticity and forgetting
Continual learning trains the same model on a sequence of task families. Each update should teach the current task without erasing skills learned from earlier tasks. These goals require separate measurements. Plasticity is the score gained on a new task after its update. Forgetting is the score lost on an earlier task after later updates. If S_i is the saved model after learning task family D_i, the gain on D_3 from S_2 to S_3 measures plasticity, while the drop on D_1 from S_1 to S_3 measures forgetting.
Self-Distillation Enables Continual Learning (2026), or SDFT, applies self-distillation to continual learning by repeating the update as each task family arrives. For each task, a teacher copy of the current model sees expert examples. The student reproduces the teacher’s behavior without those examples in its prompt, then becomes the starting point for the next task. In the paper’s three-task experiment, every update improved the new task while maintaining earlier skills. Thinking Machines’ on-policy distillation uses a related teacher distribution to recover instruction following after domain training.
Denser ≠ Better (2026) reports that SDPO specializes quickly when the teacher signal is stable, generalizes poorly outside that distribution, forgets more than GRPO during continual post-training, and can collapse. SDPO adds a loss term at every token position. If the teacher repeats a formatting artifact or biased preference across those positions, the artifact influences the update many times and can push the policy too far in the same direction.
Later methods try to learn new tasks without moving the model so far that earlier behavior degrades. SRPO (2026) and I-SDPO (2026) route selected instances toward self-distillation. SC-SDPO (2026) weights questions by estimated difficulty. PGPO (2026) changes the step size using information shared by student and teacher. SSPO (2026) attaches evidence to intermediate search actions. SPOT (2026) samples continuations from teacher-preferred tokens and scores the completed trajectories. Routing chooses trajectories, weighting sets training strength, and credit assignment chooses tokens.
Test-time SDPO: weight updates between attempts
SDPO can repeatedly update one model on a hard instance. The system generates an attempt, runs a verifier, conditions the teacher on new evidence, trains the student, and uses the updated model for the next attempt. Best-of-k samples from a fixed policy, while multi-turn repair keeps the policy fixed and adds feedback to context. On a selected LiveCodeBench v6 subset, SDPO reached a 22 percent discovery probability with about one-third as many generations as fixed-policy sampling. The result applies only to tasks that at least one compared method solved within the experiment’s screening budget.
Epistemic Uncertainty for Test-Time Discovery (2026) keeps a frozen base model and several LoRA adapters, then uses disagreement among their token distributions as an exploration bonus. The method improved maximum verified reward on three of four scientific-discovery benchmarks. The experiment used one seed and five rank-16 LoRA adapters. Storing and evaluating all five adapters adds memory, compute, and latency. It needs deterministic program checkers.
Regardless of the training method, the system must decide what happens to the updated weights after the hard instance. It can discard them, reuse them for later instances, or evaluate them as a deployment candidate. This decision determines whether learning remains temporary or changes the model used for future work.
Harness state: what changes around a model
The harness layer changes state around a frozen model, including executable agent code. A system can improve without updating model weights by updating prompts, tools, workflows, memory, or control logic.
Prompt instruction. Evaluation results guide an optimizer to rewrite the natural-language instruction for one LM call. Later calls use the revised prompt. Examples include MIPRO (2024), TextGrad (2024), and Genetic-Pareto (GEPA, 2025). Evaluation should measure validation overfit and prompt growth.
Few-shot examples. An optimizer adds high-scoring input-output traces to later prompts as examples. DSPy (2023) and MIPRO (2024) use this approach. Evaluation should measure copied errors and example leakage.
Workflow graph. Evaluation scores arrangements of agents, tools, and steps. Later tasks run the selected graph, including its routing and subagent roles. Examples include Automated Design of Agentic Systems (ADAS, 2024), Automating Agentic Workflow Generation (AFlow, 2024), and EvoAgentX (2025). Evaluation should measure search cost and weak credit assignment.
Skill or tool library. Task outcomes guide the creation or revision of reusable instruction files and executable tools for later runs. Test-Time Tool Evolution (2026) and SkillGrad (2026) are examples. Evaluation should measure wrong retrieval and unsafe code.
Memory. Completed trajectories become records or summaries that later tasks can retrieve, revise, or retire. Examples include ReasoningBank (2025), Agentic Context Engineering (ACE, 2025), and Auto-Dreamer (2026). Evaluation should measure stale records and unfaithful compression.
Whole scaffold. Search can change several harness components as one candidate configuration. The editable subset differs by system. DGM mutates a coding-agent implementation, A-Evolve mutates persistent workspace artifacts, and TTHE and Meta-Harness expose broader harness targets. Later runs load the version selected by evaluation. Representative work includes Test-Time Harness Evolution (TTHE, 2026), Darwin Godel Machine (DGM, 2025), A-Evolve (2026), and Meta-Harness (2026).
Harness evolution often uses non-gradient search over instructions, few-shot examples, workflow graphs, or entire scaffold repositories. The optimizer executes and scores candidates on a task set, then selects parents for mutation or recombination. A pool can preserve several lineages so later mutations start from different specialists. GEPA’s Pareto pool, ADAS’s archive, and DGM’s parent selection use variants of this loop.
DSPy exposes several carriers through one compile() interface. The optimizer determines which state can change.
DSPy and BootstrapFewShot (2023) retain successful traces as few-shot examples, while MIPRO (2024) jointly searches data-aware instructions and examples. SIMBA (Stochastic Introspective Mini-Batch Ascent) prioritizes training examples whose sampled scores vary. It appends either module-specific advice inferred from better and worse trajectories or a successful trajectory as a demonstration. GEPA (2025) uses textual feedback to propose new instructions, then retains any instruction that achieves the highest score so far on at least one validation example. BootstrapFinetune writes model weights, and BetterTogether (2024) sequences prompt and weight updates. The compile() interface therefore crosses the boundary between harness and model state.
GEPA: instruction search from textual feedback
Genetic-Pareto, or GEPA, uses language as feedback. An evaluator can return an error explanation and execution trace instead of a scalar reward. A reflection model uses this evidence to propose an instruction edit. GEPA tests the edited instruction on sampled examples and accepts it only when their total score improves. Accepted candidates then pass through selection and evaluation on the full validation set.
With GEPA’s built-in selection strategies, AcceptanceCriterion governs search-pool entry. A local subsample filters proposals, the full validation set scores admitted candidates, and an external gate decides whether production loads one. A custom strategy can apply another admission rule. GEPA’s 2025 paper reports more than 10 percent over MIPROv2, up to 20 percent over GRPO, and up to 35 times fewer rollouts in its evaluated settings.
Decagon ran more than 19 GEPA ablations on a classification task. Runs with 20 to 100 examples outperformed runs with 500, which produced longer prompts and worse held-out performance. A small reflection model also failed to improve the starting prompt. GEPA therefore needs prompt-length regularization, a capable reflection model, and a separate holdout.
The gskill package extends the loop from prompts to reusable skill files. GEPA starts with empty skills and sends batch results, traces, and test output to a reflection model before saving best_skills.txt. Deterministic tests screen candidates. Published results show that skills learned on Mini-SWE-Agent raised Claude Code’s pass rate on the same repositories.
Toy harness experiment using DSPy
I ran four DSPy optimizers (LabeledFewShot, BootstrapFewShot, MIPROv2, and GEPA) on 48 paraphrased support tickets adapted from the Tau2-bench Telecom domain. A response passed when it returned the predefined diagnosis and included the required term in its first suggested troubleshooting step. The mean score gave 0.75 points for the diagnosis and 0.25 for the first step.
The 24 training rows produced candidate programs, and the 12 validation rows selected them. Accepted candidates were frozen and hashed before a separate script evaluated the 12 held-out test rows. The runner did not pass the test rows or test scores to the optimizers during compilation. The procedural holdout contains six rows from task families present in training and six from new families. The experiment examined how a harness writes, selects, serializes, and reloads state. It was not designed to compare optimizer effectiveness.
Every run started from the same configuration.
instruction: Classify the support problem and name one safe, reversible first check.
input: ticket
outputs:
diagnosis: one concise problem category
first_safe_check: one safe first check
demos: []LabeledFewShot(k=3) copied three training rows into the serialized demos array without changing the initial instruction.
BootstrapFewShot also kept the instruction. One accepted candidate saved three generated traces that passed the metric and one labeled row. The excerpt shows a saved demonstration because the optimizer did not write a new instruction.
instruction: Classify the support problem and name one safe, reversible first check.
demos:
- ticket: On Wi-Fi only, my photos never leave the messaging app while normal texts go out immediately.
diagnosis: MMS configuration problem
first_safe_check: Check whether mobile data is enabled for the messaging app before changing any network settings.
- ... three more demonstrationsMIPROv2 replaced the instruction and kept three demonstrations. One candidate wrote this instruction.
You are an IT support triage assistant. Given a user's mobile connectivity ticket,
classify the issue into exactly one diagnosis family—cellular service connection,
mobile data connection, or MMS configuration—and recommend exactly one safe,
reversible first check that defers resets, reinstalls, or carrier contact.GEPA replaced the instruction and left the demos array empty. One candidate named the accepted diagnosis strings and the required terms in its instruction.
Classify the support problem into exactly one of the following three allowed
categories: "mobile data connection problem", "cellular service connection
problem", or "MMS configuration problem". ...
- For "cellular service connection problem": the first check must explicitly
mention SIM PIN, network unlock PIN, carrier provisioning code, and/or
network mode.The test results average three runs. Each cell shows the baseline score from the common starting configuration, followed by the optimized candidate's score.
Note that this is just a toy experiment using Upstage Solar Pro 4 as the model. With only 12 test rows, one result changes the pass rate by 8.3 percentage points. The saved harness state improved its score, but the experiment does not establish an optimizer ranking.
Whole-workspace evolution: prompts, skills, memory, and tools
A-Evolve expands the write target from one prompt to a workspace containing prompts/, skills/, tools/, memory/, and evolution records. The agent reads the workspace, the observer writes logs, and the evolver changes stored artifacts through one filesystem interface. Git records changes and supports rollback. The v2 implementation keeps benchmark tasks and grading outside the editable workspace. A production system should similarly keep its deployment evaluation outside the evolving system’s control.
Prime Agent implements this pattern. Its runtime stores prompt notes, memories, Python-backed skills, subagent specifications, and refinement events. Local state belongs to one session, while global state can affect later sessions.
prime-agent/prime-agent-runtime/src/rlm/harness.py
@dataclass
class HarnessEntry:
id: str
kind: HarnessKind
title: str
content: str
path: str = "general"
scope: HarnessScope = "local"
reference: dict[str, Any] = field(default_factory=dict)
arguments: dict[str, Any] = field(default_factory=dict)
metadata: dict[str, Any] = field(default_factory=dict)
source: str = "agent"
# ...
version: int = 1
@dataclass
class RefinementEvent:
id: str
trigger: str
changes: list[str]
evidence: str = ""
outcome: str = ""
# ...HarnessEntry identifies and versions retained artifacts. RefinementEvent records each change’s evidence and outcome.
Prime Agent keeps an IPython process alive and lets the model start additional model calls for subproblems while working on one task. Process state disappears when the session ends. The continual harness creates lasting change by writing prompts, memories, or skills to disk. Local entries affect later turns in the session, while global entries can affect later sessions.
The /refine path requests the smallest evidence-backed edit. It keeps the base system prompt immutable, records prior state, and can reverse a refinement by ID.
prime-agent/packages/coding-agent/src/core/refinement/refinement.ts
function rollbackProposal(target: RefinementResult): RefinementProposal {
const edits: RefinementEdit[] = [];
for (const edit of [...target.appliedEdits].reverse()) {
if (!edit.applied) continue;
if (edit.before) {
edits.push({
action: edit.after ? "update" : "create",
kind: edit.kind,
id: edit.id,
title: edit.before.title,
content: edit.before.content,
path: edit.before.path,
reference: edit.before.reference,
arguments: edit.before.arguments,
metadata: edit.before.metadata,
reason: `Rollback ${target.id}`,
});
} else if (edit.after) {
edits.push({
action: "delete",
kind: edit.kind,
id: edit.id,
reason: `Rollback ${target.id}`,
});
}
}
return {
summary: `Rollback refinement ${target.id}`,
rationale: `Restores continual harness state snapshots from refinement ${target.id}.`,
expectedOutcome: "Faulty refinement edits are reverted.",
edits,
};
}Prime Intellect reports that Prime Agent used refinement while playing Factorio, a factory-building and automation game. Remote console (RCON) lets an external program send commands to the running game server. The agent used RCON to spawn resources directly into assembly machines, bypassing normal gameplay despite an explicit instruction not to cheat. Prime Intellect calls the behavior reward hacking. The refinement loop retained the exploit as reusable skills. Persistent learning can amplify undesirable behavior when evaluation and guardrails fail to reject it.
Readable persistent state appears across current agent products. Cursor project rules, GitHub custom-agent profiles, and Anthropic Agent Skills use version-controlled or filesystem-backed instruction files. Letta Context Repositories store memory in Git-backed files, while Microsoft Agent Framework context providers can retrieve or persist state around an invocation. Cursor can generate memories from conversations, and Letta can run background memory reflection. Devin can suggest repository skills after learning a procedure, but its documentation describes suggestion rather than autonomous acceptance. Prime Agent can update persistent artifacts during a run.
Continual harnesses: forgetting and task order
Self-improvement requires gains to persist across tasks without erasing earlier capabilities. A harness update that improves the current task but breaks prior behavior is local adaptation, not continual improvement. Readable and reversible files make harness evolution easier to inspect than weight updates, but do not prevent forgetting. Compressed memory can drop safety conditions and a larger library can make useful tools harder to retrieve.
Agents that follow the Reflexion method explain why an attempt failed, store the explanation, and reuse it during later attempts. Honest Lying (2026) tested this method on ALFWorld, a text-based benchmark where agents navigate simulated homes and manipulate objects. Across sixteen tasks, the agent wrote 121 explanations, but none named the object specified by the task. Memories built directly from failed action logs named the correct object 86 percent of the time, yet the agent completed only three tasks within ten attempts. Persistent memory should therefore separate recorded actions and environment outcomes from the model’s unverified diagnosis of the failure. The diagnosis should remain temporary until later evidence confirms it.
Continual Harness (2026) updates the harness mid-episode. At fixed environment-step intervals, a Refiner reads the partial trajectory and edits prompts, subagent structure, skills, and memory without resetting the environment. Later actions use the changed harness. Across iterations, a slower co-learning loop uses trajectories to update a LoRA adapter through soft SFT. The system runs two clocks over two write targets.
Harness Continual Learning (2026) treats the harness as state that must learn new tasks without degrading earlier behavior. After each task, an optimizer proposes a replacement harness. An evaluator accepts it only if it improves the current task, limits losses on earlier tasks, and passes validity checks. In the paper’s experiment, rejecting every regression blocked useful adaptation, while accepting every locally useful change increased forgetting. A moderate tolerance produced the best final average.
The Fragility of Self-Improving Agents (2026) found that task order changed the performance of two memory-based agents, Agent Workflow Memory and ReasoningBank. Shuffling the default easy-to-hard order lowered their scores because the agents could not accumulate useful lessons before harder tasks arrived. Clearer task rubrics, environment feedback, and memory instructions recovered part of the loss, suggesting that underspecified updates contributed to the instability.
An agent can improve against one curriculum while becoming less reliable under another. Continual-learning results should publish the task sequence, repeat at least one reversed or shuffled order, and show a checkpoint-by-task matrix. A final average cannot identify forgetting.
Optimizer state: how the update process becomes a write target
An optimizer can update model, harness, or environment state. The optimizer can also become the write target.
ADAS (2024) generates complete agent programs and saves them in an archive. DGM (2025) and SICA (2025) let a coding agent rewrite the harness used by later versions while leaving the LLM weights fixed. The harness controls prompts, tools, file edits, tests, context, and subagents. DGM mutates archived agent versions and may select a result as the parent for a later mutation. SICA replaces its coding-agent implementation on each iteration.
STOP (2023) lets an improver function rewrite its own implementation. Hyperagents (2026) lets an agent edit the procedure that generates its next self-modification. STOP and Hyperagents can save the updated optimizer and use it in later iterations.
Weco’s AIDE and AlphaEvolve (2025) search over candidate programs. AIDE searches a tree of ML code candidates and directs more work to promising branches. AlphaEvolve uses LLMs to modify programs, scores them with automated evaluators, and stores promising candidates in an evolutionary database. AlphaEvolve’s stored program population evolves while the LLM weights remain fixed.
AI4AI-Bench (2026) gives an LLM agent four hours on one B300 GPU to edit a frozen training-algorithm repository from one of ten families. The submitted code trains a model from scratch for up to twelve hours, then a hidden fixed evaluator compares it with the original algorithm under the same compute budget. Scores place the repository baseline at 0.1 and the ideal at 1.0. The strongest system averaged 0.250. Learning-algorithm patches averaged 0.226, compared with 0.126 for run-setting changes, though the gap may also reflect differences in system capability. Each task ends after one submission is scored. The result does not trigger another edit, the trained model does not replace the agent, and humans choose the repository, objective, compute budget, and evaluator. AI4AI-Bench therefore measures one capability needed for recursive self-improvement rather than a recursive loop.
Decagon Autopilot applies a propose-and-evaluate structure to agent operating procedures. It turns production failures into changes to agent logic, tests revisions against the original conversation and a curated golden set, and uses failed tests to produce another revision. A human must approve the change before production. Unlike AI4AI-Bench’s fixed evaluator, Autopilot feeds test results back into the optimizer and expands the test set as conversations arrive.
Environment state: how tasks, simulators, and rewards adapt
Environment state belongs to a self-improvement loop only when results change the training environment for a future version. Human-authored or manually selected environments support training but do not contribute to self-improvement. Environment state can include a learned task proposer, curriculum, reward function, task validator, task distribution, or executable simulator. These components are not agents but still shape learning.
Self-play was an early form of this loop. Policy-Space Response Oracles (PSRO, 2017) uses match results to compute policy mixtures for later opponents. AlphaStar (2019) trains against a league of adapting strategies and counter-strategies. OpenAI Five (2019) plays 80 percent of its training games against the latest parameters and 20 percent against past versions. PSRO, AlphaStar, and OpenAI Five use policies produced during training as opponents for later versions.
Paired Open-Ended Trailblazer (POET, 2019), Protagonist Antagonist Induced Regret Environment Design (PAIRED, 2020), and XLand (2021) apply the loop to tasks and worlds. POET pairs automatic environment generation with agent optimization and transfers successful agents between retained environments. PAIRED trains an environment generator toward difficult but solvable tasks using the reward difference between protagonist and antagonist policies. XLand changes its training distribution and objectives across successive agent generations. Agent results determine the next training distribution in all three systems.
An environment-update cycle starts with a model and harness running tasks from the current environment. After an episode or training batch, an automated updater changes the task distribution, generator, curriculum, or executable environment based on the results. Rewards or verifier results from the new environment then update the model weights or harness to create a candidate.
The table shows which scores, success rates, or experiences guide recent environment updates and which agent state is trained afterward.
SPADE: executable environments from self-play
SPADE (2026) uses one language model to generate interactive tasks and learn to solve them through self-play. It creates new Python environments as the learner’s abilities change instead of training on fixed questions. The model alternates between Environment Designer and Reasoning Agent roles. The designer writes complete environments with Gym-style reset() and step() methods. The agent acts inside the programs and learns from rewards.
The generated environment contains state transitions, reward functions, verification code, and multi-turn behavior, making it a wider write target than generated questions. Malformed transitions can make tasks unsolvable, flawed rewards can teach unintended strategies, and hidden shortcuts can yield high scores without the intended skills.
SPADE targets the learner’s capability frontier with privileged hints. The reasoning agent plays an environment once without a hint and again with information that should make it solvable. A large reward gap identifies an environment that the agent can solve with the hint but not without it. Environments that remain impossible with a hint or trivial without one provide less signal.
Because the Environment Designer and Reasoning Agent use the same model, there is a risk of sharing a faulty assumption. The designer may encode the assumption in a task or reward, and the agent can learn behavior that succeeds under the faulty rule.
Acceptance authority: who approves a candidate
Self-improvement requires an acceptance role independent of the process that proposes the update. If the same process controls hidden cases, the historical suite, judge context, or deployment, it can raise the score by changing how the candidate is judged instead of improving the candidate. The process may receive gate feedback, but the gate must retain final deployment authority.
The update clock limits which acceptance gates are practical. A mid-episode update needs a low-latency check such as syntax, execution, or a deterministic environment signal. Between-task and offline updates can wait for replay, a full regression suite, or human review. Faster updates require cheaper verification or an executable environment result.
HarnessDev (2026) benchmarks harness-optimization methods. It separates the model that edits the harness from the model that runs it, freezes every candidate, and tests transfer on held-out SWE-Pro tasks and with a fixed Gemini executor. Across 64 adjacent version switches, feedback and held-out scores moved together only 53.1 percent of the time. Each creator-executor configuration was evolved only once, so the experiment does not measure variation across evolution runs. A higher development score does not establish a better deployable harness. The gate must evaluate the frozen candidate with unseen tasks and the production executor.
REEF separates candidate training from activation for model state. It can train full-weight checkpoints or versioned LoRA adapters and hot-swap the selected candidate into SGLang. A rejection keeps the current served version. The default selector accepts every successful weight-training step unless the deployment config adds an evaluation gate, so the repository demonstrates versioned update mechanics rather than evidence that every update improves the model.
Self-Authored Verification Is Unreliable (2026) studies agents that can change both how they act and how their performance is scored. Self-assigned scores stayed near perfect while sealed deployment performance stalled or regressed. The independent gate returned only an accept-or-reject decision to the agents. With the gate in place, deployed performance exceeded the unprotected setting for all six models in the comparison.
LLM judges: reliability and selection errors
An LLM judge may score open-ended work when a deterministic verifier is unavailable. Rubrics and external evidence can make the evaluation easier.
Competence, Not Accuracy (2026) studies the narrower case of reference-free evaluation on single-answer tasks. On a task with k choices, random guessing answers 1/k of the questions correctly. Under the paper’s model, a reference-free judge below that baseline has no reliable basis for judging another answer, so exceeding the baseline is a prerequisite, not proof of reliability. The paper uses within-question AUC, comparing correct and incorrect answers to the same question so task difficulty cannot inflate the score. In the paper’s reference-free setup, Sonnet received neither a gold answer nor a rubric. Its within-question AUC was 0.489 on research math and 0.735 on factual QA. The research-math result was below the random-ranking baseline of 0.5. In a small closed-loop pilot, a math judge produced worse final performance than random selection. The factual judge with AUC 0.735 did not admit regressions but rejected 44 percent of real improvements. The pilot used only two or three seeds, showing the failure mode without establishing a universal threshold.
Judge evaluation has two axes. False acceptance measures how often a weak candidate passes, while false rejection measures how much useful adaptation the gate blocks. A conservative but incompetent judge can prevent every update and continual improvement.
Production gates: evaluation and human approval
Commercial platforms include evaluation or approval controls for agent changes.
Decagon Autopilot. Autopilot turns production issues into changes to agent operating procedures. It tests each change on the original conversation and a curated golden set, then requires human approval before production.
RELAI. The continual-learning platform validates proposed changes during optimization against a growing collection of prior learning environments.
Understudy. Understudy combines model routing and optimization. It compares prompts, models, and tuned weights on customer evaluations, and a candidate route can replace the baseline only after clearing a held-out quality bar.
Each product combines evaluation with a broader optimization or agent-management system rather than a standalone gate.
Industry landscape
Descriptions and results come from first-party materials, with open implementations and research papers named when available. This is a selected list rather than an exhaustive company directory, and it excludes major frontier labs.
Research organizations: systems and approaches
These companies publish different kinds of work, including closed research systems, open-source frameworks, and research programs.
Recursive has developed an automated AI research system that retains experiment branches, research procedures, and discovered code. Public evidence includes training scripts, GPU kernels, and repeated NanoChat results. Stronger search also exposed evaluation exploits. The system is closed.
Sakana AI operates the RSI Lab, an internal research group focused on recursive self-improvement. Its portfolio includes DGM, which maintains an archive of agent variants, and the open-source ShinkaEvolve program-evolution framework. The DGM paper documents archived agent lineages. The RSI Lab’s broader effort remains a research program rather than one unified system.
Weco developed AIDE², a recursive self-improvement system that retains successive versions of the AIDE research agent. AIDE² reportedly accepted seven versions across 100 iterations and tested selected versions on held-out task families. The recursive-loop implementation is closed.
Discovery Loop says it is building systems that automate experimental loops, beginning with machine-learning research and engineering. The company plans to use its own technology stack as the first improvement target. As of September 4, 2026, the cited page does not name a system, specify a retained object or promotion gate, or report a completed generation.
Poetiq develops the Poetiq Metasystem, which the company describes as a self-optimizing optimizer. The Metasystem retains its code and model-independent harnesses. Its public evidence consists of first-party benchmark results showing transfer across model providers. The core system is closed.
Hexo Labs develops SIA, an open-source self-improvement framework that retains harness and weight updates across task-agent generations. The SIA paper covers three task domains, and the implementation exposes the update loop and generation artifacts. Its public materials do not include a production study.
Kayba maintains
recursive-improve, an open-source toolchain that turns execution traces into code and prompt changes. It stores each improvement cycle on a branch, benchmarks the result, and keeps or reverts the change. Its public materials do not include a production study.
A working update mechanism does not establish a full recursive handoff. Candidate generation and retention may be public even when an accepted candidate does not become the next optimizer.
Production organizations: applications and training services
This group includes a deployed application owner, model-training platforms, a memory service, a skill-optimization platform, and a training method intended for production feedback.
Shopify operates Sidekick and its production GraphQL agent. Shopify controls the merchant traces, hard-negative mining, judge calibration, harness changes, fine-tuning data, daily model updates, and deployment decision. Privacy, stale traces, and forgetting still require controls.
Applied Compute develops AC2, a model-customization platform with support for on-policy and relevance-masked self-distillation. AC2 exposes stored traces, feedback hints, teacher-student differences, and token-level updates. Customers supply the outcome signal and regression coverage, so they retain promotion authority under this post’s boundary.
Thinking Machines Lab offers Tinker, a managed training API that supports fine-tuning, reinforcement learning, and on-policy distillation. Customers control the data, training objective, retained checkpoints, and deployment decision. Tinker supplies training infrastructure but does not establish an autonomous feedback loop.
Trajectory reports an off-policy extension of SDPO for delayed trajectories and later feedback. Its SDPO++ experiment raised the APEX-Agents pass rate from 5 to 25 percent. The result is first-party, and the cited report says training on live production traces was still planned. The report describes a training method rather than a named commercial product.
River AI offers the River API for LoRA fine-tuning, reinforcement learning, and serving. Customers supply their data and rewards and can keep and version the resulting checkpoints. The API provides training infrastructure but does not establish an autonomous feedback loop.
Starlight Search offers Reflect, a learning API and memory layer. Reflect turns reviewed trajectories into stored reflections and adjusts retrieval utility from later pass-or-fail outcomes. The customer or user supplies those outcomes and controls whether the retrieved guidance enters a deployed agent. Public materials do not include a controlled benchmark or released server implementation.
Warp develops Skill Doctor and Warp Factories, which score past agent conversations and propose changes to persistent Skill files. Its automated optimization loop repeatedly runs, grades, and revises a Skill. Users control whether proposed changes enter deployed instructions, and public evidence is limited to first-party examples and claims.
Infrastructure and science organizations: platforms and programs
These organizations work at different layers.
Microsoft combines Microsoft Foundry services into a learning loop and contributes to OpenEnv, a community protocol for reinforcement-learning environments. Foundry supplies hosted agents, sandboxing, traces, evaluations, harness optimization, post-training, and deployment services. OpenEnv defines the portable environment contract rather than serving as Microsoft’s product.
Prime Intellect offers Lab, a training platform that manages tasks, harnesses, evaluations, training runs, and adapter deployment. The company separately develops Prime Agent, an open-source coding harness that can update prompts, skills, memory, and subagent specifications. Lab and Prime Agent cover separate parts of the update loop rather than one demonstrated recursive system.
Arize offers AX, an agent evaluation and optimization platform. Its prompt optimizer uses evaluation or human feedback to generate versioned prompt candidates, while experiments compare the candidates before a user tags one for production. The platform exposes the update and promotion process, but public materials do not include a controlled production study showing continued gains across repeated cycles.
Ricursive Intelligence is developing self-improving systems for chip design. The company’s stated approach connects AI-guided chip development with hardware that supports later AI systems. Its team previously worked on AlphaChip, whose earlier implementation is public. The cited page does not name Ricursive’s current system or publish implementation details or measured results for it.
Mirendil says it is building self-accelerating AI for automated research. Its public description mentions parallel experiments, training, inference, and research workloads but does not name a product or service. The cited page does not provide a mechanism, benchmark, paper, or implementation.
Lila Sciences develops the Lila Iris scientific reasoning model and AI Science Factories that connect the model with tools, verifiers, and autonomous laboratories. The company’s technical description says experiment results become training data for successive model generations. Public evidence for the complete learning loop remains first-party.
Periodic Labs says it is building AI scientists and autonomous laboratories, beginning with the physical sciences. Its public description says laboratory experiments generate data and mentions custom agents trained for industrial researchers. The cited page does not name the AI scientist or show an updated agent becoming the next research improver.
CuspAI operates the AI Materials Foundry, a partner network for AI-driven materials discovery. Its published workflow covers candidate generation, property simulation, synthesis, and laboratory validation. The public description does not show validation results updating the AI system used for the next discovery cycle.
Edison Scientific develops Kosmos, an AI scientist for research and development teams, and Aviary, an open-source framework used to train science agents. Kosmos can use an organization’s experimental history and proprietary data, while the company’s training infrastructure uses reinforcement-learning environments and pipelines. Public materials do not show an improved Kosmos agent training its successor.
References
Paper versions and public web pages were checked on September 4, 2026. ArXiv links resolve to the versions available on that date.
[1] Karten, et al. “Continual Harness: Online Adaptation for Self-Improving Foundation Agents.” arXiv preprint arXiv:2605.09998, 2026.
[2] Xia, et al. “Live-SWE-agent: Can Software Engineering Agents Self-Evolve on the Fly?” arXiv preprint arXiv:2511.13646, 2025.
[3] Kadu and Krishnan. “ReflexGrad: Within-Episode Failure Recovery in LLM Agents via Progress-Gated Dual-Process Routing.” arXiv preprint arXiv:2511.14584, 2025.
[4] Hübotter, et al. “Reinforcement Learning via Self-Distillation.” arXiv preprint arXiv:2601.20802, 2026.
[5] Xu, et al. “TacoMAS: Test-Time Co-Evolution of Topology and Capability in LLM-based Multi-Agent Systems.” arXiv preprint arXiv:2605.09539, 2026.
[6] Zweiger, et al. “Self-Adapting Language Models.” arXiv preprint arXiv:2506.10943, 2025.
[7] Zhang, et al. “OPD-Evolver: Cultivating Holistic Agent Evolver via On-Policy Distillation.” arXiv preprint arXiv:2606.17628, 2026.
[8] Kleine Buening, et al. “Aligning Language Models from User Interactions.” arXiv preprint arXiv:2603.12273, 2026.
[9] Ye, et al. “Auto-Dreamer: Learning Offline Memory Consolidation for Language Agents.” arXiv preprint arXiv:2605.20616, 2026.
[10] Wang, et al. “MetaSkill-Evolve: Recursive Self-Improvement of LLM Agents via Two-Timescale Meta-Skill Evolution.” arXiv preprint arXiv:2607.05297, 2026.
[11] Gao, et al. “A Survey of Self-Evolving Agents: What, When, How, and Where to Evolve on the Path to Artificial Super Intelligence.” arXiv preprint arXiv:2507.21046, 2025.
[12] Lu, et al. “Beyond Static Tools: Test-Time Tool Evolution for Scientific Reasoning.” arXiv preprint arXiv:2601.07641, 2026.
[13] Sun, et al. “Learning to (Learn at Test Time): RNNs with Expressive Hidden States.” arXiv preprint arXiv:2407.04620, 2024.
[14] Zhang, et al. “Fast Weight Attention for Continual Learning.” arXiv preprint arXiv:2608.27763, 2026.
[15] Zuo, et al. “TTRL: Test-Time Reinforcement Learning.” arXiv preprint arXiv:2504.16084, 2025.
[16] Wang, et al. “Learning What to Remember: Test-Time Training via Context Distillation.” arXiv preprint arXiv:2608.01672, 2026.
[17] Shenfeld, et al. “Self-Distillation Enables Continual Learning.” arXiv preprint arXiv:2601.19897, 2026.
[18] Wang, et al. “ThetaEvolve: Test-time Learning on Open Problems.” arXiv preprint arXiv:2511.23473, 2025.
[19] Novikov, et al. “AlphaEvolve: A coding agent for scientific and algorithmic discovery.” arXiv preprint arXiv:2506.13131, 2025.
[20] Kale and Trajectory Labs. “Scaling SDPO.” Trajectory Labs Field Notes, 2026.
[21] Lu and Thinking Machines Lab. “On-Policy Distillation.” Thinking Machines Lab, 2025.
[22] Wang, et al. “Denser ≠ Better: Limits of On-Policy Self-Distillation for Continual Post-Training.” arXiv preprint arXiv:2607.01763, 2026.
[23] Li, et al. “Unifying Group-Relative and Self-Distillation Policy Optimization via Sample Routing.” arXiv preprint arXiv:2604.02288, 2026.
[24] Zhang, et al. “I-SDPO: Instance-Level Adaptive Self-Distillation Policy Optimization.” arXiv preprint arXiv:2608.12957, 2026.
[25] Liu, et al. “Restoring the Sweet Spot: Pass-Rate Weighted Self-Distillation for LLM Reasoning.” arXiv preprint arXiv:2605.27765, 2026.
[26] Wang, et al. “Physics-Guided Policy Optimization with Self-Distillation.” arXiv preprint arXiv:2606.03620, 2026.
[27] Wu, et al. “Beyond Outcome Rewards: Step-Level Self-Distilled Policy Optimization for Deep Search Agents.” arXiv preprint arXiv:2608.12764, 2026.
[28] Qu, et al. “SPOT: Sparse Probing and Outcome Calibration for On-Policy Distillation.” arXiv preprint arXiv:2608.04419, 2026.
[29] Riaz, et al. “Epistemic Uncertainty for Test-Time Discovery.” arXiv preprint arXiv:2605.11328, 2026.
[30] Opsahl-Ong, et al. “Optimizing Instructions and Demonstrations for Multi-Stage Language Model Programs.” arXiv preprint arXiv:2406.11695, 2024.
[31] Yuksekgonul, et al. “TextGrad: Automatic ‘Differentiation’ via Text.” arXiv preprint arXiv:2406.07496, 2024.
[32] Agrawal, et al. “GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning.” arXiv preprint arXiv:2507.19457, 2025.
[33] Khattab, et al. “DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines.” arXiv preprint arXiv:2310.03714, 2023.
[34] Hu, Lu, and Clune. “Automated Design of Agentic Systems.” arXiv preprint arXiv:2408.08435, 2024.
[35] Zhang, et al. “AFlow: Automating Agentic Workflow Generation.” arXiv preprint arXiv:2410.10762, 2024.
[36] Wang, et al. “EvoAgentX: An Automated Framework for Evolving Agentic Workflows.” arXiv preprint arXiv:2507.03616, 2025.
[37] Wang, et al. “SkillGrad: Optimizing Agent Skills Like Gradient Descent.” arXiv preprint arXiv:2605.27760, 2026.
[38] Ouyang, et al. “ReasoningBank: Scaling Agent Self-Evolving with Reasoning Memory.” arXiv preprint arXiv:2509.25140, 2025.
[39] Zhang, et al. “Agentic Context Engineering: Evolving Contexts for Self-Improving Language Models.” arXiv preprint arXiv:2510.04618, 2025.
[40] Nie, et al. “TTHE: Test-Time Harness Evolution.” arXiv preprint arXiv:2607.08124, 2026.
[41] Zhang, et al. “Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents.” arXiv preprint arXiv:2505.22954, 2025.
[42] Lin, et al. “Position: Agentic Evolution Is the Path to Evolving LLMs.” arXiv preprint arXiv:2602.00359, 2026.
[43] Lee, et al. “Meta-Harness: End-to-End Optimization of Model Harnesses.” arXiv preprint arXiv:2603.28052, 2026.
[44] Stanford NLP. “SIMBA implementation in DSPy 3.3.1.” GitHub source for release 3.3.1.
[45] Soylu, Potts, and Khattab. “Fine-Tuning and Prompt Optimization: Two Great Steps that Work Better Together.” arXiv preprint arXiv:2407.10930, 2024.
[46] GEPA contributors. “acceptance.py in release v0.1.4.” GitHub source snapshot.
[47] Wang. “Optimizing GEPA for Production: A Test-Driven Approach to Prompt Engineering.” Decagon, 2026.
[48] Prime Intellect. “harness.py in release v0.8.1.” GitHub source snapshot.
[49] Prime Intellect. “refinement.ts in release v0.8.1.” GitHub source snapshot.
[50] Karten, Zhang, Thomas, Müller, and Prime Intellect. “Prime Agent: A Self-Improving RLM Agent.” Prime Intellect, 2026.
[51] Dixit, Kamal, and Oates. “Honest Lying: Understanding Memory Confabulation in Reflexive Agents.” arXiv preprint arXiv:2605.29463, 2026.
[52] Kang, et al. “Harness Continual Learning: Continual Adaptation Beyond Model Parameters.” arXiv preprint arXiv:2608.19013, 2026.
[53] Ye, et al. “On the Fragility of Self-Improving Agents: Variance, Task Order, and Underspecification.” arXiv preprint arXiv:2608.18066, 2026.
[54] Robeyns, Szummer, and Aitchison. “A Self-Improving Coding Agent.” arXiv preprint arXiv:2504.15228, 2025.
[55] Zelikman, Lorch, Mackey, and Kalai. “Self-Taught Optimizer (STOP): Recursively Self-Improving Code Generation.” arXiv preprint arXiv:2310.02304, 2023.
[56] Zhang, et al. “Hyperagents.” arXiv preprint arXiv:2603.19461, 2026.
[57] Weco AI. “AIDE: An LLM Agent for Machine Learning Engineering.” GitHub source snapshot at commit 60b3978.
[58] A-EVO Lab contributors. “A-Evolve v2 Design.” GitHub source snapshot at commit 18ba996.
[59] Cursor. “Rules.” Cursor documentation.
[60] Chi, et al. “AI4AI-Bench: Benchmarking LLM Agents in Algorithmic Design for Recursive Self-Improvement.” arXiv preprint arXiv:2608.20318, 2026.
[61] Jiang. “Introducing Duet Autopilot: The Self-Improving Agent for Conversational AI.” Decagon, 2026.
[62] Lanctot, et al. “A Unified Game-Theoretic Approach to Multiagent Reinforcement Learning.” arXiv preprint arXiv:1711.00832, 2017.
[63] Vinyals, et al. “Grandmaster Level in StarCraft II Using Multi-Agent Reinforcement Learning.” Nature, 575:350–354, 2019.
[64] OpenAI, et al. “Dota 2 with Large Scale Deep Reinforcement Learning.” arXiv preprint arXiv:1912.06680, 2019.
[65] Wang, Lehman, Clune, and Stanley. “Paired Open-Ended Trailblazer (POET): Endlessly Generating Increasingly Complex and Diverse Learning Environments and Their Solutions.” arXiv preprint arXiv:1901.01753, 2019.
[66] Dennis, et al. “Emergent Complexity and Zero-Shot Transfer via Unsupervised Environment Design.” arXiv preprint arXiv:2012.02096, 2020.
[67] Open Ended Learning Team, et al. “Open-Ended Learning Leads to Generally Capable Agents.” arXiv preprint arXiv:2107.12808, 2021.
[68] Xue, et al. “Autonomous Continual Learning for Environment Adaptation of Computer-Use Agents.” arXiv preprint arXiv:2602.10356, 2026.
[69] Li, et al. “SpatialEvo: Self-Evolving Spatial Intelligence via Deterministic Geometric Environments.” arXiv preprint arXiv:2604.14144, 2026.
[70] Yue, et al. “Dr. Zero: Self-Evolving Search Agents without Training Data.” arXiv preprint arXiv:2601.07055, 2026.
[71] Liu, et al. “SPADE: Self-Play in Adaptive Synthetic Executable Environments.” arXiv preprint arXiv:2608.19197, 2026.
[72] Human-Agent-Society contributors. “REEF.” GitHub source snapshot at commit 73d5d80.
[73] Guo, et al. “Self-Authored Verification Is Unreliable in Heuristic Self-Improving Agents.” arXiv preprint arXiv:2607.24300, 2026.
[74] Chen, et al. “Competence, Not Accuracy: A Diagnostic for Reference-Free Judge Gates in Skill Optimization.” arXiv preprint arXiv:2608.18719, 2026.
[75] RELAI. “Introducing RELAI: Verifiable Continual Learning for AI Agents.” RELAI, 2026.
[76] Understudy. “We Watch Your Agent Work, Then Train a Smarter and Cheaper Successor.” Understudy product page.
[77] Recursive. “First Steps Toward Automated AI Research.” Recursive, 2026.
[78] Sakana AI. “Introducing Sakana AI’s Recursive Self-Improvement Lab.” Sakana AI, 2026.
[79] Sakana AI. “ShinkaEvolve: Evolving New Algorithms with LLMs, Orders of Magnitude More Efficiently.” Sakana AI, 2025.
[80] Weco AI. “AIDE²: First Evidence of Recursive Self-Improvement.” Weco AI, 2026.
[81] Discovery Loop. “Continuous Exploration.” Discovery Loop company site.
[82] Poetiq. “A Poetiq Perspective on Recursive Self-Improvement.” Poetiq, 2026.
[83] Hexo Labs. “Open Source Self-Improving AI.” Hexo Labs, 2026.
[84] Hebbar, et al. “SIA: Self Improving AI with Harness & Weight Updates.” arXiv preprint arXiv:2605.27276, 2026.
[85] Hexo AI contributors. “SIA (Self-Improving AI).” GitHub source snapshot at commit 7fd04d0.
[86] Kayba. “recursive-improve: Make Your Agents Recursively Self-Improve.” GitHub source snapshot at commit 9cf4b85.
[87] Shopify. “Sidekick’s Continual Learning Loop.” Shopify Engineering, 2026.
[88] Applied Compute. “Productionizing Self-Distillation Methods.” Applied Compute, 2026.
[89] River AI. “API.” River AI documentation.
[90] Starlight Search. “Introduction.” Reflect documentation.
[91] Kamtamneni. “Outcome-Driven Learning Systems: Enterprise RL with OpenEnv and Foundry.” Microsoft Foundry Blog, 2026.
[92] Prime Intellect Team. “Releasing Lab: the training platform for self-improving agents.” Prime Intellect, 2026.
[93] Ricursive Intelligence. “Recursive Self-Improvement via AI for Chip Design & Chip Design for AI.” Ricursive Intelligence company site.
[94] Google Research. “AlphaChip: An open-source framework for generating chip floorplans with distributed deep reinforcement learning.” GitHub repository.
[95] Mirendil. “Scaling self-accelerating AI with Google.” Mirendil, 2026.
[96] Lila Sciences. “Solutions.” Lila Sciences product page.
[97] Lila Sciences. “Tech.” Lila Sciences technical overview.
[98] Periodic Labs. “Periodic Labs.” Periodic Labs company site.
[99] CuspAI. “AI-powered materials discovery.” CuspAI company site.
[100] Edison Scientific. “Kosmos: The AI Scientist for R&D Teams.” Edison Scientific product page.
[101] Laurent, Narayanan, Hong, and Magness. “Accelerating Science at Scale.” Edison Scientific, 2026.
[102] Wu, et al. “HarnessDev: Can LLMs Create and Evolve Their Own Agent Harness?” arXiv preprint arXiv:2609.01437, 2026.
[103] GEPA contributors. “gskill: Learning Repository-Specific Skills.” GEPA documentation, 2026.
[104] Tan, et al. “Automatically Learning Skills for Coding Agents.” GEPA, 2026.
[105] Sierra Research. “Tau2-bench Telecom domain in release v1.0.1.” GitHub source snapshot.
[106] Poetiq. “Recursive Self-Improvement Delivers New State-of-the-Art Coding Performance.” Poetiq, 2026.
[107] Thinking Machines Lab. “Tinker.” Thinking Machines Lab product page.
[108] Warp. “Skill Doctor: Score and Improve Your Agent Skills.” Warp product page, 2026.
[109] Arize. “Arize AX: AI Engineering Platform for Self-Improving AI Agents.” Arize product page, 2026.
[110] Bai. “Building a Skill Optimization Loop.” Warp Engineering, 2026.
[111] GitHub. “Custom agents configuration.” GitHub Docs.
[112] Anthropic. “Agent Skills.” Claude Platform documentation.
[113] Letta. “Introducing Context Repositories: Git-based Memory for Coding Agents.” Letta, 2026.
[114] Microsoft. “Context provider integrations.” Microsoft Learn, 2026.
[115] Cognition. “Skills.” Devin documentation.
[116] Y Combinator. “rekursiv.ai.” Y Combinator company directory, 2026.
[117] Dasein. “Continual Learning Infrastructure.” Dasein company site.
[118] ReflexioAI contributors. “Reflexio.” GitHub repository.