SelfAdapt: Adaptive System Reconfiguration

• SelfAdapt is a family of mechanisms that enable systems to dynamically adjust internal parameters, policies, or structures at deployment to handle uncertainty.
• It leverages closed-loop feedback architectures such as MAPE-K and context-oriented programming, using internal signals from current conditions and execution history to drive adaptation.
• Applications span medical imaging, vision, cyber-physical control, and optimization, where dynamic adaptation improves key metrics like Dice scores and inference accuracy.

SelfAdapt denotes a family of mechanisms in which a model, software system, or network reconfigures its own parameters, policy, or structure in response to deployment-time uncertainty rather than relying entirely on fixed offline design. In recent arXiv literature, this includes single-subject source-free medical image adaptation (He et al., 2020), single-sample test-time adaptation in vision (Bartler et al., 2022, Bahmani et al., 2022), unlabeled post-deployment personalization of self-supervised sensing models (Yoon et al., 2024), source-free cell-segmentation adaptation (Reith et al., 15 Aug 2025), runtime adaptation-rule synthesis in self-adaptive software (Ishimizu et al., 2024), and self-calibrating proactive autoscaling in container orchestration (Baghel, 15 May 2026). The common thread is a closed loop in which the system observes its current operating condition, derives an internal adaptation signal from that condition or from recent execution history, and updates behavior, control parameters, or topology without requiring a separate target-domain retraining pipeline.

1. Conceptual scope and formal viewpoints

In software-engineering treatments, self-adaptation is typically expressed as a feedback loop. A self-adaptive system can reconfigure at run time in response to changing situations so as to maintain acceptable behavior under uncertainty, and this is commonly organized through MAPE-K or closely related decompositions (Fredericks et al., 2022, Yang et al., 2017, Päßler et al., 2023). The managed/managing split is explicit in the formal modeling of an autonomous underwater vehicle, where the managed subsystem is a family of valid feature configurations and the managing subsystem is a control layer that dynamically switches among them according to environmental and internal conditions (Päßler et al., 2023). In context-oriented programming, the same idea appears as context activation and deactivation plus modular behavioral variation; Auto-COP extends this by learning new context-specific behaviors at runtime rather than restricting the system to design-time adaptations (Cardozo et al., 2021).

A requirements-oriented formulation places adaptation logic directly in goal models. REDAPT proposes an adaptive goal model, specifies dynamic properties with a logic-based grammar, derives adaptation mechanisms from these specifications, and realizes adaptation through monitoring variables, diagnosing requirements violations, determining reconfigurations, and execution (Yang et al., 2017). A simpler but conceptually aligned formulation appears in self-adaptive game logic, where goals, utility functions, thresholds, and reconfiguration strategies become runtime entities inside the game loop rather than remaining design-time documentation (Fredericks et al., 2022).

This suggests that SelfAdapt is not tied to a single representation. Depending on domain, the adaptive object may be a context-specific software behavior, a feature configuration, a task-network parameter subset, a reward function, a learning rate, a mutation rate, or a communication structure.

2. Recurrent architectural patterns

Across the literature, self-adaptation appears at several distinct loci.

Locus of adaptation	What changes online	Representative works
Runtime software behavior	Contexts, rules, feature configurations	Auto-COP (Cardozo et al., 2021), REDAPT (Yang et al., 2017), ProFeat AUV (Päßler et al., 2023)
Inference-time model behavior	Adaptors, feature extractors, BN statistics, replayed SSL parameters	SDA-Net (He et al., 2020), TTAPS (Bartler et al., 2022), Semantic Self-adaptation (Bahmani et al., 2022), SelfReplay (Yoon et al., 2024), SelfAdapt (Reith et al., 15 Aug 2025)
Control and planning parameters	Planning horizon, rule sets, adaptation policies	ADAPT (Baghel, 15 May 2026), LLM rule optimization (Ishimizu et al., 2024), MeRAP (Zhang et al., 2021)
Optimization and search internals	Loss weights, learning rates, proposal kernels, mutation rates	SoftAdapt (Heydari et al., 2019), DSA (Chen et al., 2022), Individual Adaptation (Griffin et al., 2014), discrete EA self-adaptation (Case et al., 2020)
Collective or network structure	Agent placement, topology evolution	Structural self-adaptation (Nikolic et al., 2019), adaptive network (Bai et al., 2024)

A unifying design choice is the use of an internal proxy for misalignment. In medical image adaptation, source-trained auto-encoders or prototype assignments act as source-likeness priors (He et al., 2020, Bartler et al., 2022). In semantic segmentation, augmentation-consistent pseudo-labels and interpolated normalization statistics supply the adaptation signal (Bahmani et al., 2022). In autoscaling, observed cold-start duration drives replanning (Baghel, 15 May 2026). In adaptive MCMC and evolutionary computation, mutation success or proposal mutation rate becomes the feedback signal for reconfiguring the search process itself (Griffin et al., 2014, Case et al., 2020).

3. Test-time and source-free adaptation of learned models

The most concentrated recent use of SelfAdapt appears in domain shift and test-time learning. The “self domain adapted network” decomposes deployment into a frozen task model $T$, source-trained auto-encoders, and lightweight adaptors. At test time, only the adaptors are optimized, with objective $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$, where auto-encoder reconstruction enforces source-likeness and spectral restricted isometry regularization constrains feature adaptors against collapse. In retinal OCT segmentation, overall Dice on the Cirrus target domain rises from $0.749$ with no adaptation to $0.793$ with SDA-Net and $0.806$ with the $3\times 3$ image-adaptor variant; in MRI synthesis, target-center MSE improves from $0.223$ to $0.168$ on HH, from $0.271$ to $0.233$ on GH, and from $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$0 to $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$1 on IOP, with about $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$2 s adaptation per subject versus about $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$3 s for testing without adaptation (He et al., 2020).

TTAPS adapts a SwAV-trained representation to a single test image by replacing the training-time balanced assignment constraint with a test-time softmax assignment,

$$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$4

and then updating only the feature extractor, typically the last ResNet block, on multiple augmentations of that same image. Its full training objective is $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$5, where the entropy term makes prototypes class-relevant. On CIFAR10-C at severity 5, TTAPS reaches $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$6 average accuracy, compared with $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$7 for the supervised baseline, $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$8 for MEMO, and $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$9 for MT3 (Bartler et al., 2022).

Semantic self-adaptation for segmentation operates at two levels: test-time fine-tuning of selected convolutional blocks using confidence-filtered, augmentation-consistent pseudo-labels, and Self-adaptive Normalization, which interpolates source and per-sample BatchNorm statistics via

$0.749$0

For GTA-trained ResNet-50, the SaN baseline has mean mIoU $0.749$1 across Cityscapes, BDD, and IDD, while self-adaptation reaches $0.749$2; for ResNet-101 the corresponding means are $0.749$3 and $0.749$4. The method is not real time: on a single RTX 2080, mean runtime for ResNet-50 rises from $0.749$5 ms with SaN alone to $0.749$6 ms with full self-adaptation (Bahmani et al., 2022).

SelfReplay, formulated in the paper as ADAPT$0.749$7, targets post-deployment personalization of self-supervised sensing models. It meta-trains an encoder so that replaying the original self-supervised loss on a few target-user samples is effective, with inner-loop update

$0.749$8

outer-loop update

$0.749$9

and target-side replay before final few-shot supervised tuning. For SimCLR, average F1 improves from $0.793$0 under linear evaluation to $0.793$1 with ADAPT$0.793$2; on a Samsung Galaxy S20 Ultra, SimCLR replay takes $0.793$3 s with $0.793$4 memory consumption, while CPC replay takes $0.793$5 s with $0.793$6 memory consumption (Yoon et al., 2024).

The 2025 method explicitly titled “SelfAdapt” for cell segmentation is a source-free UDA procedure built on student-teacher augmentation consistency, L2-SP regularization, and label-free stopping criteria. The self-training term combines masked cross-entropy and masked MSE, and L2-SP adds

$0.793$7

On base Cellpose models, LiveCell Cytoplasm AP$0.793$8 rises from $0.793$9 to $0.806$0 with embedding-based early stopping and to $0.806$1 with oracle test-max; TissueNet Nuclei rises from $0.806$2 to $0.806$3 and $0.806$4 respectively. The fixed label-free stopping thresholds are $0.806$5 and $0.806$6 (Reith et al., 15 Aug 2025).

4. Self-adaptive software and cyber-physical control

Outside perception, self-adaptation often denotes automatic synthesis or selection of runtime behavior. In SWIM, “Automatic Adaptation Rule Optimization via LLMs” treats rule design itself as the adaptation problem. The LLM acts as Analyzer and Planner in a design-time MAPE-K loop, receiving domain description, adaptation goals, variables, historical operational data, and existing rule behavior, then outputting executable C++ rules. Each experiment runs for $0.806$7 iterations, with $0.806$8 experiments per LLM. Both GPT-4 and DeepSeek-Coder-V2 reach about $0.806$9k utility in the best cases, outperforming the default manually designed SWIM rules, but the optimization is unstable, non-monotonic, and each iteration explores only one node in the design space (Ishimizu et al., 2024).

ADAPT addresses a different locus: the controller’s anticipation horizon. It estimates cold-start duration online with an EWMA and feeds the resulting dynamic planning horizon, FH-OPT, into an MPC that optimizes replica counts over a rolling window. Across three policies, six workload archetypes, and five random seeds, MPC+LSTM achieves below $3\times 3$0 SLA violation on all workloads, compared with $3\times 3$1–$3\times 3$2 for reactive HPA and up to $3\times 3$3 for MPC+Prophet on bimodal traffic (Baghel, 15 May 2026).

Auto-COP moves context-oriented programming from selection of predefined adaptations to generation of new ones at runtime. It logs state-action-reward traces, extracts RL options as candidate action sequences, evaluates them with Q-learning,

$3\times 3$4

and compiles the highest-Q option for a state into a COP context plus behavioral variation. In the driving assistant case, generated adaptations reduce wrong-lane violations from $3\times 3$5 to $3\times 3$6 over $3\times 3$7 decision points while the system actuates $3\times 3$8 learned adaptations; in the warehouse robot case, the paper reports that the number of required execution or actuation steps is reduced by a factor of two (Cardozo et al., 2021).

Formal and requirements-driven strands emphasize analyzability. In the AUV case study modeled in ProFeat, the managed subsystem has four valid feature configurations, the full system is an MDP, and the minimum probability of eventually reaching done is $3\times 3$9 in both analyzed scenarios; reward analysis shows, for example, Scenario 1 energy min/max of $0.223$0 and $0.223$1, and Scenario 2 energy min/max of $0.223$2 and $0.223$3 (Päßler et al., 2023). In self-adaptive game logic, a browser game instrumented with a MAPE-K loop and utility functions was evaluated with $0.223$4 replicates per treatment; players were engaged significantly longer with MAPE-K enabled, and the average utility for Goal (F) was significantly higher $0.223$5 (Fredericks et al., 2022). REDAPT generalizes this viewpoint by proposing adaptive goal models with logic-based specifications that derive monitoring, diagnosis, reconfiguration, and execution mechanisms at requirements time (Yang et al., 2017).

5. Self-adjusting algorithms, optimizers, and structures

Several papers treat SelfAdapt as adaptation of the learning or search process itself. MeRAP formalizes a self-learning adaptive system as $0.223$6, synthesizes multiple MDPs from alternative environment, capability, and objective models, and meta-learns a policy initialization using a MAML-style objective. In the robotic case study, MeRAP adapts in no more than ten gradient steps in most cases, and the fastest variant, MeRAP_V3, has replanning time equal to $0.223$7 of OPE’s replanning time while retaining nearly optimal reward (Zhang et al., 2021).

SoftAdapt adjusts multi-part loss weights online from recent loss slopes. The original rule is a softmax over rates of change,

$0.223$8

with variants that normalize slopes or additionally weight by current loss magnitude. In sparse autoencoders on MNIST, the PCC metric improves from $0.223$9 to $0.168$0 at epoch $0.168$1, from $0.168$2 to $0.168$3 at epoch $0.168$4, and from $0.168$5 to $0.168$6 at epoch $0.168$7 relative to fixed $0.168$8; in IntroVAE, training time is essentially unchanged at $0.168$9 versus $0.271$0 minutes (Heydari et al., 2019).

Differentiable Self-Adaptive Learning Rate makes learning rates parameter-specific and internally structured. It updates internal variables $0.271$1 using a look-ahead gradient product and maps them through a sigmoid-bounded step size. On ResNet-18, the reported accuracies are $0.271$2 on MNIST, $0.271$3 on SVHN, $0.271$4 on CIFAR10, and $0.271$5 on CIFAR100, exceeding the paper’s Momentum and Hypergradient baselines on those benchmarks (Chen et al., 2022).

In Bayesian variable selection, Individual Adaptation learns separate add and delete proposal probabilities $0.271$6 for each variable and targets a user-specified mutation rate rather than a plain acceptance rate. On Tecator, the best IA variants achieve ESS around $0.271$7, compared with about $0.271$8 for multi-move MH and about $0.271$9 for the adaptive sampler of Lamnisos et al.; on the PCR dataset with $0.233$0 variables, MCA-IA-PT remains stable across independent runs (Griffin et al., 2014).

Discrete evolutionary computation supplies a different meaning of self-adaptation: the mutation rate is encoded in the chromosome and evolves with the population. For the non-elitist self-adaptive $0.233$1 EA on $0.233$2, the expected runtime is $0.233$3, which simplifies to $0.233$4 under the paper’s stated conditions and matches the asymptotic runtime achievable when the hidden parameter $0.233$5 is known in advance (Case et al., 2020). Structural self-adaptation in decentralized pervasive intelligence adapts neither task policy nor scalar parameters but agent placement on an isomorphic communication tree. The paper evaluates $0.233$6 deterministic structural criteria, reports a benchmark involving $0.233$7 million structural self-adaptations and almost $0.233$8 billion exchanged messages, and concludes that the more exploratory online strategy is the most cost-effective (Nikolic et al., 2019).

A thermodynamic line of work pushes the idea further to topology filtering under unknown environments. The adaptive network paper derives an acceptance rule

$0.233$9

updates the estimated environment landscape by a Wang–Landau-style rule, and reports power-law decay $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$00 with $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$01 for adaptive systems, compared with $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$02 for memoryless systems (Bai et al., 2024).

6. Limitations, trade-offs, and open problems

A persistent limitation in test-time adaptation is the strength of the shift assumption. SDA-Net is designed for relatively minor domain shifts and explicitly does not claim to handle severe cross-modality transfer such as MRI-to-CT (He et al., 2020). TTAPS improves average corruption robustness but is not uniformly beneficial: on CIFAR10-C, test-time adaptation hurts on fog, glass blur, motion blur, pixelate, and very slightly on zoom blur, while gains on CIFAR100-C are smaller (Bartler et al., 2022). Semantic self-adaptation can propagate confident but wrong pseudo-labels, although fewer than $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$03 of images worsen on average and less than $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$04 deteriorate by as much as $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$05 IoU (Bahmani et al., 2022). SelfReplay assumes domain labels during pretraining and addresses a single post-deployment adaptation event rather than continual adaptation (Yoon et al., 2024). The cell-segmentation SelfAdapt method depends critically on L2-SP and early stopping; removing L2-SP drops TissueNet Nuclei AP$$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$06 from $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$07 to $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$08 in the ablation (Reith et al., 15 Aug 2025).

Software and control settings expose different trade-offs. LLM-based rule optimization in SWIM is promising in best-case utility but unstable, expensive, and limited by one-candidate-per-iteration search (Ishimizu et al., 2024). ADAPT can only correct timing, not forecast quality; the large degradation of MPC+Prophet relative to MPC+LSTM shows that adaptive planning horizons do not compensate for poor demand prediction (Baghel, 15 May 2026). Auto-COP learns reusable action sequences, but the paper itself notes the risk that long options may become unsafe if the environment changes during adaptation execution (Cardozo et al., 2021). In the AUV case, family-based probabilistic model checking is effective on the simplified model, yet scalability to larger models is left explicitly open (Päßler et al., 2023).

Algorithmic self-adaptation also inherits domain-specific assumptions. MeRAP depends on the real runtime task being covered or at least approximated by the offline model base; uncovered user objectives can trap the system in a local optimum (Zhang et al., 2021). SoftAdapt introduces its own sensitivity parameter $$\mathcal{L}_A=\mathcal{L}_{AE}+\lambda_{orth}\mathcal{L}_{orth}$$09 and can underperform in some regimes if the sign and scale of that parameter are poorly chosen (Heydari et al., 2019). DSA incurs an extra look-ahead gradient evaluation per iteration and is described by its own authors as ill-suited to ordinary minibatch training, which is why they use it primarily as a batch-style fine-tuning stage after minibatch pretraining (Chen et al., 2022). The thermodynamic adaptive-network formulation relies on environmental detailed balance; the paper notes that this may fail in strongly nonequilibrium environments (Bai et al., 2024).

Across these strands, SelfAdapt is best understood not as a single algorithmic recipe but as a research program organized around one recurring question: how much adaptation can be pushed into the running system itself. The answer varies by field, but the literature converges on three durable themes: adaptation requires an endogenous proxy for misalignment, it benefits from explicit modularization of what is allowed to change, and it remains constrained by the fidelity of the internal signal on which the system adapts.