Self-Adaptive Systems

Topic

Modern software systems closely interact with external entities (e.g., users, external services, and physical entities), whose changes occur at runtime and are impossible to be completely predicted at development time. How does such a system address the changes in the environment? A self-adaptive system that (1) monitors the changes, (2) analyzes and plans modification of structure and/or behavior of the system to maintain its qualities, and (3) executes the plan during system execution, is known as a promising approach.

We are working on models@run.time techniques that utilize runtime models to make assured decisions about self-adaptation, targeting application domains such as cloud-native systems, federated learning, flight software, and robot control.

Purpose

A self-adaptive software is comprised of “adaptable software” realizing application logics and an “adaptation engine” realizing adaptation logics. This research aims to establish a development process for an assured and high-quality adaptation engine.

Technical Overview

We apply control theory and artificial intelligence techniques to enable the models@run.time approach for self-adaptive systems.

  • Environment model learning at runtime Techniques to automatically reflect unforeseen environmental changes into the environment model at runtime. We apply hypothesis finding and stochastic gradient descent to enable fast and accurate learning of the environment model.

  • Specification model synthesis at runtime Techniques to automatically generate a “correct” specification model at runtime. We apply discrete controller synthesis (DCS) — a formal technique that generates a behavior specification model guaranteed to satisfy given properties under a given environment model (→ see the Discrete Controller Synthesis page).

  • Models@run.time framework (IEEE TSE 2022) A framework enacting a specification model by orchestrating given software components. The framework enables runtime reconfiguration without stopping the system.

Self-Adaptive Defense in Federated Learning

We apply the MAPE-K loop to federated learning security, where the system must detect and respond to attacks that evolve at runtime.

  • Self-adaptive defense against dynamic poisoning attacks (Hu et al., SEAMS 2025) A MAPE-K-based defense mechanism that detects and responds in real time to poisoning attacks whose patterns change dynamically.

  • UCB-based self-adaptive defense (Hu et al., KBSE 2026) Combines statistical upper confidence bound (UCB) methods with self-adaptation so that the federated learning server automatically excludes malicious clients.

User Preference Adaptation

We study methods for autonomous systems to dynamically adapt to individual user preferences from complaint-based feedback.

  • Adaptive Preferences: Pivoting Through User Complaints (Zhang et al., TAAS 2025) Analyzes user complaint feedback and dynamically refines adaptation rules to better align with user preferences.

  • Multi-grained requirement relaxation (Li et al., RE'22) Achieves flexible self-adaptation by relaxing requirements according to their priority and granularity.

Application Domains

  • Cloud-native intrusion recovery (KBSE 2024)
  • NASA F’ flight software (COMPSAC 2024)
  • Ambient Assisted Living (SEAMS 2026)
  • Robot control, IoT systems (→ see the Discrete Controller Synthesis page)

Selected Publications

  • Chenyu Hu et al. “Adapting Aggregation Rule for Robust Federated Learning under Dynamic Attacks.” SEAMS 2025.
  • Chenyu Hu et al. “UCB-based Self-Adaptive Defense in Federated Learning.” KBSE 2026.
  • Mingyue Zhang et al. “Adaptive Preferences: Pivoting Through User Complaints.” ACM TAAS, 2025.
  • Jialong Li et al. “Done is better than perfect: Iterative Adaptation via Multi-grained Requirement Relaxation.” RE 2022.
  • Jialong Li et al. “Generative AI for Self-Adaptive Systems: State of the Art and Research Roadmap.” ACM TAAS, 2024.
  • Jialong Li et al. “Self-Adaptive Cloud-Native Intrusion Recovery.” KBSE 2024.
  • Kenji Tei et al. “Towards scalable model checking of reflective systems via labeled transition systems.” IEEE Transactions on Software Engineering, 2022.