Closed-Loop Self-Evolution in Adaptive Systems

• Closed-loop self-evolution is a feedback mechanism where systems iteratively detect and correct errors based on their own outputs.
• It employs structured steps—generation, sensing, diagnosis, and control—to refine performance in areas like language processing, robotics, and autonomous driving.
• Empirical studies show measurable gains in accuracy and safety, demonstrating its practical impact in real-world adaptive systems.

Searching arXiv for papers on closed-loop self-evolution and closely related frameworks. Closed-loop self-evolution is a feedback-governed mode of adaptation in which a model, agent, or simulator uses the consequences of its own outputs as inputs to subsequent correction, planning, or parameter updates. In recent arXiv work, the term is used across several distinct regimes: output-level self-correction in LLMs, within-episode repair in robotics, on-policy recovery in autonomous driving, lifelong strategy refinement in dialogue, protocol-level resource evolution in multi-agent systems, and mutual co-evolution of optimizers and task solvers (Wu et al., 17 May 2026, Ming et al., 2023, Zhang et al., 12 Jan 2026, Zhang, 16 Apr 2026). A central distinction is that some frameworks perform transient, episode-bounded self-correction, whereas others implement persistent improvement across tasks through memory, versioned resources, evolving strategy banks, or explicit parameter updates (Ming et al., 2023, Lin et al., 14 Mar 2026).

1. Definition and conceptual scope

Closed-loop self-evolution denotes an iterative process in which generation, execution, or inference is not treated as a one-shot open-loop mapping. Instead, the system senses deviations, computes some internal or externalized error signal, and feeds corrective information back into the same process. In CyberCorrect, this is stated as the operationalization of iterative, feedback-driven improvement of an LLM’s outputs, grounded in a cybernetic control framing, with the LLM treated as a plant whose outputs are continuously sensed, diagnosed, and corrected until stability is reached (Wu et al., 17 May 2026). In data-centric autonomous driving, the same phrase refers to a continuous cycle in which fleet incidents and corner cases are mined, labeled, retrained on, validated, deployed, and monitored, so that outcomes feed back into the pipeline automatically (Li et al., 2024). In dialog, DarwinTOD defines a dual-loop system in which online multi-agent execution and offline structured evolutionary operations refine an Evolvable Strategy Bank over generations (Zhang et al., 12 Jan 2026).

The literature also separates closed-loop self-correction from stronger forms of self-evolution. HiCRISP explicitly describes its behavior as within-task, on-the-fly plan and action repair driven by feedback, while noting that persistent improvement across tasks through parameter or memory updates is not the primary focus (Ming et al., 2023). This matters because closed-loop behavior can exist entirely at the output or execution level without changing the underlying model parameters. A plausible implication is that “self-evolution” is best understood as a family of mechanisms rather than a single algorithmic template.

A stricter formulation appears in work on self-evolving language-model reasoning, where the algorithm has access only to an unlabeled prompt set and a base model, and all supervision signals are generated internally by the same model acting as generator, verifier, and reviser (Qi et al., 31 May 2026). That strict setup makes the concept analytically sharp: improvement is allowed, but the resulting performance can be directly compared with oracle-supervised upper bounds. Related work argues that self-play alone often plateaus because generating more synthetic data does not necessarily increase learnable information for the next iteration (Liu et al., 10 Feb 2026).

2. Canonical feedback architecture

A common architectural pattern is a typed feedback loop comprising generation or execution, sensing, diagnosis, control, and termination. CyberCorrect provides the clearest formalization. For a task $x$, the generator output at iteration $t$ is $y_t$, the control input is a targeted correction prompt $u_t$, and the plant update is

$y_{t+1} = \mathcal{G}(x,\ y_t,\ u_t).$

The sensor produces an error signal

$$e_t = (\tau_t,\ s_t,\ \ell_t) = \text{classify}\!\big(\mathcal{E}(y_t)\big),$$

where $\tau_t$ is an error category, $s_t \in [0,1]$ is severity, and $\ell_t$ is the localized step index. The controller law is

$u_t = \mathcal{C}(\tau_t,\ s_t,\ \ell_t).$

This yields a closed-loop map from $t$0 to $t$1 through sensing and control, with a Convergence Judge imposing stability criteria, oscillation detection, rollback, and a bounded iteration budget (Wu et al., 17 May 2026).

A protocol-level generalization appears in Autogenesis. There, the evolvable substrate consists of prompts, agents, tools, environments, memory, and execution artifacts, and the loop is abstracted as Reflect, Select, Improve, Evaluate, and Commit over a universal evolvable variable set $t$2 (Zhang, 16 Apr 2026). The core point is not merely that state can change, but that every change is mediated by typed interfaces, version lineage, and rollback. This moves closed-loop self-evolution from heuristic prompt rewriting to auditable state transition.

Embodied and simulation systems instantiate the same logic with different state variables. In HiCRISP, perception-derived binary flags trigger either low-level predefined correction structures or high-level replanning by the LLM planner (Ming et al., 2023). In closed-loop trajectory prediction, the ego model repeatedly executes its own predicted trajectory inside a reactive simulator, experiences self-induced states, and is supervised to recover toward the logged trajectory (Yadav et al., 25 Mar 2026). In $t$3, adversarial synthesis and policy fine-tuning form a cycle in which the synthesizer probes weaknesses in the current ego policy, the policy is updated on boundary cases, and the improved policy is then re-evaluated by the same mechanism (Guo et al., 8 Apr 2026).

3. Representative operational forms

The following systems illustrate the range of implementations.

System	Domain	Closed-loop element
CyberCorrect	LLM reasoning	typed error detection, repair prompts, convergence control
HiCRISP	robotic task planning	perception flags, bounded correction stack, replanning
DarwinTOD	task-oriented dialog	online peer critique, offline strategy evolution
FAR-Drive	autonomous-driving simulation	frame-level autoregressive self-conditioning
AGS	multi-agent systems	resource versioning, evaluate/commit/rollback
Escher-Loop	program optimization	task/optimizer co-evolution with dynamic benchmarking

At the output level, CyberCorrect senses self-consistency, verbalized confidence, and logic-chain validity, fuses them into a typed error report, and applies severity-adaptive repair instructions (Wu et al., 17 May 2026). In offline self-evolution for reasoning, candidate solutions are generated, self-verified, optionally revised, converted into preference data, and then used for DPO updates, but all signals remain internal to the same base model (Qi et al., 31 May 2026). ACL-SPC for point-cloud completion uses a different feedback variable: it generates a completion, renders viewpoint-induced partial observations from that completion, feeds them back through the same network, and enforces consistency between the re-completions and the original completion (Hong et al., 2023).

In embodied and interactive settings, the loop is typically stateful and environment-coupled. HiCRISP inserts corrective actions when execution deviates from the desired high-level path, uses a bounded stack to prevent correction loops from running indefinitely, and routes failures between high-level LLM replanning and low-level primitive correction (Ming et al., 2023). Goal-oriented reactive simulation trains a trajectory predictor on a mixture of open-loop data and simulated self-induced states so that the model learns recovery behaviors under covariate shift (Yadav et al., 25 Mar 2026). FAR-Drive turns closed-loop simulation into frame-level autoregressive world evolution by feeding previously generated frames back into a multi-view diffusion transformer conditioned on ego motion, bounding boxes, maps, and camera geometry (Li et al., 16 Mar 2026). SPIRAL similarly casts action world modeling as a think–act–reflect process with a PlanAgent, a CriticAgent, memory, local regeneration, outer-loop replanning, and GRPO-based persistent improvement (Yang et al., 9 Mar 2026).

Persistent self-evolution across tasks is most explicit in strategy- and population-based systems. DarwinTOD maintains an Evolvable Strategy Bank whose strategies are selected by domain-aware Boltzmann selection and then modified by Genesis, Mutation, Consolidation, and Pruning (Zhang et al., 12 Jan 2026). Escher-Loop maintains two populations—Task Agents and Optimizer Agents—so that optimizer ability is itself subjected to closed-loop selection pressure using the empirical scores of newly generated task agents as relative win–loss signals (Liu et al., 25 Apr 2026). ASI-Evolve turns long-horizon AI research into a learn–design–experiment–analyze cycle in which a cognition base injects prior knowledge and an analyzer converts multi-signal experimental outputs into reusable insights for future iterations (Xu et al., 31 Mar 2026).

4. Error signals, objectives, and update rules

The object being minimized or optimized varies sharply across domains. CyberCorrect defines a typed error signal with category, severity, and localization, and adds control-theoretic stability criteria such as

$t$4

oscillation detection through answer cycling, and rollback when severity increases beyond a safety threshold (Wu et al., 17 May 2026). In noisy-label learning, the classifier $t$5 and neural correction function $t$6 co-evolve through decoupled bilevel optimization, with corrected labels updated through a convex combination of historical corrections chosen to minimize clean-set validation risk (Lin et al., 14 Mar 2026). In self-healing neural networks, residuals from learned manifold embeddings become the control objective, and feedback inputs are optimized to steer hidden states back toward the clean-data manifold during inference (Chen et al., 2022).

Some systems optimize through explicit risk or transport objectives. In $t$7, adversarial scenario generation is cast as transport-regularized sparse control over a reverse-time SDE prior, with a KL-regularized quadratic energy penalizing deviation from the nominal path distribution (Guo et al., 8 Apr 2026). FAR-Drive uses flow matching, adaptive reference-horizon conditioning, and blend-forcing to reduce autoregressive degradation under self-conditioning (Li et al., 16 Mar 2026). In ASI-Evolve, fitness is not a single scalar in all domains: architecture search uses normalized quantitative metrics plus LLM-as-a-Judge scores, data curation uses analyzer-based pair ratings and coverage diagnostics, and RL algorithm design uses weighted benchmark performance with judge scores (Xu et al., 31 Mar 2026).

A recurring design choice is whether the feedback is internal, external, or mixed. Strict self-evolution in reasoning uses only internally generated verification and revision signals (Qi et al., 31 May 2026). AGP/AGS allows heterogeneous external tools and environments, but routes all mutation through a typed commit surface so that resource evolution remains closed-loop at the protocol level (Zhang, 16 Apr 2026). A plausible implication is that “closed-loop” does not require purely self-generated supervision; rather, it requires that evaluation outcomes be recursively reinjected into subsequent state transitions.

5. Evaluation criteria and empirical behavior

Recent work increasingly evaluates the dynamics of correction, not just final accuracy. CyberCorrect introduces convergence rate, overshoot rate, and oscillation rate as control-theoretic metrics, and on CyberCorrect-Bench reports 79.8% final accuracy, a +6.2 percentage-point improvement over CoVe at 73.6%, an overshoot rate of 8.2%, an oscillation rate of 3.6%, and a convergence rate of 81.2% (Wu et al., 17 May 2026). Its iteration-wise accuracy improves monotonically and stabilizes by iterations 2–3, while removing the Error Detector, type-directed correction, Convergence Judge, or rollback degrades both accuracy and stability. This makes explicit that closed-loop self-evolution is partly about trajectory quality, not only endpoint quality.

In embodied and driving settings, the dominant metrics are safety, realism, and collision avoidance. $t$8 improves collision failure discovery by 9.01% on nuScenes and up to 21.43% on nuPlan over the strongest baselines while maintaining low invalidity and high realism, and its recycled boundary cases produce large robustness gains under closed-loop policy fine-tuning (Guo et al., 8 Apr 2026). Goal-oriented reactive simulation reports relative collision rate reductions of up to 27.0% on nuScenes and 79.5% in dense DeepScenario intersections compared to open-loop baselines, with a 50/50 hybrid of reactive and log-replay surrounding agents giving the best overall balance between interactivity and stability (Yadav et al., 25 Mar 2026). FAR-Drive, by contrast, is evaluated on FVD, mAP, mIoU, and latency, and achieves state-of-the-art performance among existing closed-loop autonomous driving simulation approaches while maintaining sub-second latency on a single GPU (Li et al., 16 Mar 2026).

For lifelong or protocolized systems, the evidence is distributed across benchmark families. DarwinTOD reports continuous performance gains across generations and state-of-the-art results on MultiWOZ, including 120.59 Combine on MultiWOZ 2.0 with GPT-5.1 (Zhang et al., 12 Jan 2026). AGS achieves 89.04% average Pass@1 on GAIA with evolve tool, surpassing ToolOrchestra at 87.38% and HALO at 85.38%, and also improves GPQA-Diamond, AIME24, AIME25, and multi-language coding pass rates under closed-loop prompt, tool, or solution evolution (Zhang, 16 Apr 2026). ASI-Evolve reports 105 state-of-the-art linear attention architectures, a +3.96 average benchmark gain in pretraining data curation, and reinforcement-learning algorithm gains of up to +12.5 on AMC32, +11.67 on AIME24, and +5.04 on OlympiadBench (Xu et al., 31 Mar 2026).

A more critical empirical result comes from strict closed-loop reasoning. On Knights and Knaves, self-evolution consistently improves over the base model but plateaus after excessive training compute is invested and still leaves a non-trivial gap to oracle supervision. For Gemma 3 4B, the base model scores 31.0% All, SimpleSE reaches 40.7%, RevisionSE 42.2%, iterative SE 44.1%, and curriculum SE 44.8%, whereas oracle-supervised variants reach 46.6% or 53.3% depending on setup (Qi et al., 31 May 2026). With Gemma 3 12B, RevisionSE reaches 52.8% All against 53.6% for oracle verification, showing that the gap can become small but does not disappear automatically (Qi et al., 31 May 2026).

6. Limitations, misconceptions, and future directions

A common misconception is that closed-loop behavior automatically implies persistent learning. HiCRISP explicitly states that its adaptation is largely transient within the episode, with bounded correction depth and no explicit long-term policy updates (Ming et al., 2023). CyberCorrect likewise provides output-level self-improvement with practical stability thresholds but no formal convergence guarantees, and notes that any Lyapunov interpretation is heuristic because the severity signal is an estimated, model-internal proxy rather than a true norm (Wu et al., 17 May 2026). Closed-loop self-evolution therefore spans a continuum from inference-time repair to durable cross-task adaptation.

Another misconception is that more internal feedback necessarily produces open-ended improvement. Work on self-synthetic pipelines argues that sustainable self-evolution requires increasing learnable information across iterations; otherwise the loop synthesizes more data without increasing useful structure for the next update (Liu et al., 10 Feb 2026). The strict closed-loop study of reasoning reaches a related conclusion from another angle: internally generated supervision helps, but remains insufficient to match oracle supervision in general, especially when verifier reliability is weak or the task lacks deterministic structure (Qi et al., 31 May 2026). This suggests that verifier quality, task verifiability, and information gain are first-order constraints.

The practical limitations are similarly recurrent across domains: higher compute and latency from repeated sensing and correction, restricted taxonomies of detectable errors, sparse or noisy feedback, multistability or drift in long-horizon rollouts, and the absence of formal convergence proofs (Wu et al., 17 May 2026, Li et al., 16 Mar 2026, Guo et al., 8 Apr 2026). Several papers point toward comparable remedies: adaptive thresholds and learned controllers in CyberCorrect, memory and meta-feedback in output-level self-evolution, experience memory and online learning for HiCRISP, meta-policies that shorten search in AuDirector and ASI-Evolve, and protocol-native commit/rollback surfaces in AGP (Wu et al., 17 May 2026, Ming et al., 2023, Ren et al., 12 May 2026, Xu et al., 31 Mar 2026, Zhang, 16 Apr 2026).

A plausible synthesis is that the field is converging on three requirements for robust closed-loop self-evolution. First, the system must sense the right variable: a typed reasoning error, a failure predicate, a verifier judgment, or a transport-regularized risk signal. Second, it must have a controlled actuation surface: local edits, replanning, resource mutation, or parameter update. Third, it must manage stability: convergence thresholds, rollback, bounded horizons, ranking mechanisms, or versioned commit policies. Where those three elements are explicit, closed-loop self-evolution becomes not just iterative improvement, but an engineered feedback system with inspectable dynamics.