Abstract

The growing scale, complexity, interconnectivity, and autonomy of
modern software ecosystems introduce unprecedented levels of un
certainty, challenging the foundations of traditional self-adaptation.
Existing self-adaptive techniques, often based on rule-driven con
trollers or isolated learning components, struggle to generalize
across novel contexts and coordinate responses across distributed
subsystems, leaving them ill-equipped to handle emergent "un
known unknowns" in complex, dynamic environments. Recent dis
cussions on Self Adaptation 2.0 established an equal partnership
between AI and adaptive systems, merging learning-driven intelli
gence with adaptive control to enable predictive, data-driven, and
proactive adaptation. Building on this foundation, we introduce a
new wave of self-adaptation through POLARIS a three-layer multi
agentic self-adaptation framework that moves beyond reactiveadap
tation by combining (1) a low-latency Adapter layer for monitoring
and safe execution, (2) a transparent Reasoning layer that gener
ates and verifies plans using tool-aware, explainable agents, and (3)
a Meta layer that records experiences and meta-learns improved
adaptation policies over time. By using shared knowledge and pre
dictive models, POLARIS can handle uncertainty, learn from its
past actions, and evolve its strategies, enabling the engineering
of autonomous systems that can anticipate change to ensure re
silient and goal-directed behavior under uncertainty. Preliminary
evaluation across two distinct self-adaptive exemplars, SWIM and
SWITCH, demonstrates that POLARIS consistently outperforms
existing state-of-the-art baselines. With this, we motivate a shift
towards Self-Adaptation 3.0 akin to Software 3.0, a new paradigm
where systems move beyond merely learning from their environ
ment to reasoning about and evolving their own adaptation. In this
vision, adaptation contributes to a self-learning process that enables
systems to continuously improve and respond to novel challenges.

Abstract

The integration of IoT devices and the development of smart cities have brought about significant changes in urban infrastructure. Smart spaces represent a pivotal use case, exemplifying the integration of IoT sensors to enhance automation and decision-making. In these environments, interoperability is critical when incompatible devices interact, enabling seamless communication and optimized performance. To the best of our knowledge, this is the first work that presents a comparative evaluation of systems with and without interoperability, focusing on the end-to-end system performance highlighting the importance of interoperability in real-time smart space control. Towards this, we implemented a multi-layered architecture consisting of a novel Controller Layer (CL) that drives the interactions between air quality sensing and actuation of the window and air purifier. Additionally, the architecture consists of the Device Layer (DL), Data Monitoring Layer (DML), and Data Storage Layer (DSL). The DML uses oneM2M as middleware to achieve interoperability among indoor and outdoor air-quality sensors and actuators, such as a window controller and an air purifier. Our focus is on assessing the end-to-end performance of the interconnected nature of dependent actions and the significance of response time between incompatible devices. Experimental results show correlations between window controller and air-purifier states based on sensor data, offering insights into achieving interoperability in smart spaces and improving real-time air-quality management.

Abstract

Architecture Decision Records (ADRs) play a critical role in preserving the rationale behind system design, yet their creation and maintenance are often neglected due to the associated authoring overhead. This paper investigates whether Large Language Models (LLMs) can mitigate this burden and, more importantly, how different strategies for presenting historical ADRs as context influence generation quality. We curate and validate a large corpus of sequential ADRs drawn from 750 open-source repositories and systematically evaluate five context selection strategies (no context, All-history, First-K, Last-K, and RAFG) across multiple model families. Our results show that context-aware prompting substantially improves ADR generation fidelity, with a small recency window (typically 3-5 prior records) providing the best balance between quality and efficiency. Retrieval-based context selection yields marginal gains primarily in non-sequential or cross-cutting decision scenarios, while offering no statistically significant advantage in typical linear ADR workflows. Overall, our findings demonstrate that context engineering, rather than model scale alone, is the dominant factor in effective ADR automation, and we outline practical defaults for tool builders along with targeted retrieval fallbacks for complex architectural settings.

Abstract

Architecture Knowledge Management (AKM) is crucial for maintaining current and comprehensive software Architecture Knowledge (AK) in a software project. However AKM is often a laborious process and is not adopted by developers and architects. While LLMs present an opportunity for automation, a naive, single-prompt approach is often ineffective, constrained by context limits and an inability to grasp the distributed nature of architectural knowledge. To address these limitations, we propose an Agentic approach for AKM, AgenticAKM, where the complex problem of architecture recovery and documentation is decomposed into manageable sub-tasks. Specialized agents for architecture Extraction, Retrieval, Generation, and Validation collaborate in a structured workflow to generate AK. To validate we made an initial instantiation of our approach to generate Architecture Decision Records (ADRs) from code repositories. We validated our approach through a user study with 29 repositories. The results demonstrate that our agentic approach generates better ADRs, and is a promising and practical approach for automating AKM.

Abstract

Context. The rise of Large Language Models (LLMs) has led to their widespread adoption in development pipelines.
Goal. We empirically assess the energy efficiency of Python code generated by LLMs against human-written code and code developed by a Green software expert.
Method. We test 363 solutions to 9 coding problems from the EvoEval benchmark using 6 widespread LLMs with 4 prompting techniques, and comparing them to human-developed solutions. Energy consumption is measured on three different hardware platforms: a server, a PC, and a Raspberry Pi for a total of ≈881h (36.7 days).
Results. Human solutions are 16% more energy-efficient on the server and 3% on the Raspberry Pi, while LLMs outperform human developers by 25% on the PC. Prompting does not consistently lead to energy savings, where the most energy-efficient prompts vary by hardware platform. The code developed by a Green software expert is consistently more energy-efficient by at least 17% to 30% against all LLMs on all hardware platforms.
Conclusions. Even though LLMs exhibit relatively good code generation capabilities, no LLM-generated code was more energy-efficient than that of an experienced Green software developer, suggesting that as of today there is still a great need of human expertise for developing energy-efficient Python code.

Abstract

Large Language Models (LLMs) are increasingly used in software engineering, yet their role in architectural refactoring, particularly in decomposing monolithic systems into microservices, remains largely unexplored, even though such decomposition, when necessary, is difficult and error-prone, especially when identifying meaningful service boundaries.
This exploratory study investigates how LLMs can support architects through a multi-step decomposition process that applies seven summarisation strategies and four LLMs to generate architectural views and candidate decompositions. We assess these decompositions using six established metrics across four open-source systems that provide both monolithic and microservice versions, enabling comparison with reference architectures.
Results show that LLM-based decompositions outperform traditional techniques on Cyclic Independence (+22.7), approaching reference architectures and indicating better technical dependency management. Traditional automated approaches remain stronger at recovering the ground-truth structure (MoJoFM +24.1), team alignment (TC +11.0), and domain-oriented boundaries (DI +10.7). No significant differences appear for Code Modularity or Business Context Purity, suggesting that LLMs produce clean decompositions with few cyclic dependencies but still struggle to reproduce the exact target decomposition.

Abstract

Context: Architecture views are essential for soft-
ware architecture documentation, yet their manual creation is labor-intensive and often leads to outdated artifacts. As systems grow in complexity, the automated generation of views from source code becomes increasingly valuable.
Goal: We empirically evaluate the ability of LLMs and agentic approaches to generate architecture views from source code.
Method: We analyze 340 open-source repositories across 13 experimental configurations using 3 LLMs with 3 prompting techniques and 2 agentic approaches, yielding 4,137 generated views. We evaluate the generated views by comparing them with the ground-truth using a combination of automated metrics complemented by human evaluations.
Results: Prompting strategies offer marginal improvements. Few-shot prompting reduces clarity failures by 9.2% compared to zero-shot baselines. The custom agentic approach consistently outperforms the general purpose agent, achieving the best clarity
(22.6% failure rate) and level of detail success (50%).
Conclusions: LLM and agentic approaches demonstrate capabilities in generating syntactically valid architecture views. However, they consistently exhibit granularity mismatches, operating at the code level rather than architectural abstractions. This suggests
that there is still a need for human expertise, positioning LLMs and agents as assistive tools rather than autonomous architects.

Abstract

This study investigates the performance, energy efficiency, and resource consumption of four agentic issue resolution frameworks (SWE-Agent, OpenHands, Mini SWE Agent, and AutoCodeRover) when constrained to Small Language Models (SLMs). Results indicate that framework architecture is the primary driver of energy consumption, but current frameworks fail to operate efficiently with SLMs, often leading to unproductive reasoning loops and low task resolution rates.

Abstract

Energy efficiency has emerged as a vital attribute of software quality,
with significant implications for both environmental sustainability
and operational costs. However, existing profiling tools operate
only at runtime and coarse granularity, typically capturing energy
at the process or method level. Such tools fail to expose how small
code blocks, such as functions, loops, and conditionals, contribute to
energy consumption, preventing developers from reasoning about
and comparing the energy efficiency of programming constructs
during design-time.
To address this gap, we propose EnCoDe, a methodology for
fine-grained, design-time energy estimation, with the following
key contributions: (1) PowerLens, a novel measurement method-
ology that achieves reliable sub-millisecond energy readings for
small code blocks; (2) Extensive empirical study on code blocks
extracted from over 18,000 Python programs, uncovering linear and
non-linear relationships between energy consumption and static
code features such as structural, complexity, density, and contextual
characteristics, resulting in a first-of-its-kind fine-grained dataset;
and (3) Predictive modeling, in which machine learning models
are trained on these features to accurately estimate and classify
block-level energy consumption at design-time. Our results demon-
strate stable, reproducible block-level estimations, with regressors
achieving 𝑅2 = 0.75 and classifiers achieving 80.6% accuracy in
identifying energy hotspots, enabling developers to localize and
address inefficient code regions early in the development process
without execution

Abstract

LLMs have advanced code generation, but their use for generating microservices with explicit dependencies and API contracts remains understudied. We examine whether AI agents can generate functional microservices and how different forms of contextual information influence their performance. We assess 144 generated microservices across 3 agents, 4 projects, 2 prompting strategies, and 2 scenarios. Incremental generation operates within existing systems and is evaluated with unit tests. Clean state generation starts from requirements alone and is evaluated with integration tests. We analyze functional correctness, code quality, and efficiency. Minimal prompts outperformed detailed ones in incremental generation, with 50-76% unit test pass rates. Clean state generation produced higher integration test pass rates (81-98%), indicating strong API contract adherence. Generated code showed lower complexity than human baselines. Generation times varied widely across agents, averaging 6-16 minutes per service. AI agents can produce microservices with maintainable code, yet inconsistent correctness and reliance on human oversight show that fully autonomous microservice generation is not yet achievable.