Task offloading in edge-cloud computing systems requires determining optimal allocation of application components across heterogeneous infrastructure while balancing multiple objectives, like energy consumption, latency, or cost. This problem becomes particularly complex in large-scale deployments (e.g., smart cities, industrial IoT) where existing approaches fail to address collective phenomena, namely emergent system-wide behaviors like network congestion that arise from multi-device interactions, leading to suboptimal offloading decisions in large-scale deployments. To address these challenges this paper introduces a multi-agent learning framework for collective component offloading that decomposes applications into a directed acyclic graph of macro-components, enabling partial offloading where individual components can be selectively executed locally or migrated to edge/cloud servers. Our system model represents the infrastructure as a heterogeneous graph of application devices and infrastructure nodes, supporting decentralized offloading decisions while maintaining component interdependencies. In particular, we propose Informed Deep Hetero Graph Q-Learning (IDHGQL), which combines: (1) Heterogeneous Graph Neural Networks (HeteroGNNs) for policy representation that naturally handle diverse device types and relationships; (2) Aggregate computing to enrich device observations with collective system state information; and (3) a multi-agent Deep Q-Learning algorithm based on centralized training with decentralized execution that balances individual constraints with emergent collective phenomena. Experimental evaluation demonstrates IDHGQL’s effectiveness in multi-objective optimization scenarios, successfully learning policies that balance battery consumption, latency, and infrastructure costs. In density-aware scenarios, agents learn spatially-adaptive strategies that dynamically adjust offloading decisions based on local congestion: favoring local execution in high-density areas to avoid network bottlenecks while leveraging edge/cloud resources in sparse regions. Ablation studies confirm that collective information integration is essential for learning such context-aware policies, with IDHGQL consistently outperforming static baselines across all evaluated metrics.

In the last years, Federated learning (FL) has become a popular solution to train machine learning models in domains with high privacy concerns. However, FL scalability and performance face significant challenges in real-world deployments where data across devices are non-independently and identically distributed (non-IID). The heterogeneity in data distribution frequently arises from spatial distribution of devices, leading to degraded model performance in the absence of proper handling. Additionally, FL typical reliance on centralized architectures introduces bottlenecks and single-point-of-failure risks, particularly problematic at scale or in dynamic environments. To close this gap, we propose Field-Based Federated Learning (FBFL), a novel approach leveraging macroprogramming and field coordination to address these limitations through: (i) distributed spatial-based leader election for personalization to mitigate non-IID data challenges; and (ii) construction of a self-organizing, hierarchical architecture using advanced macroprogramming patterns. Moreover, FBFL not only overcomes the aforementioned limitations, but also enables the development of more specialized models tailored to the specific data distribution in each subregion. This paper formalizes FBFL and evaluates it extensively using MNIST, FashionMNIST, and Extended MNIST datasets. We demonstrate that, when operating under IID data conditions, FBFL performs comparably to the widely-used FedAvg algorithm. Furthermore, in challenging non-IID scenarios, FBFL not only outperforms FedAvg but also surpasses other state-of-the-art methods, namely FedProx and Scaffold, which have been specifically designed to address non-IID data distributions. Additionally, we showcase the resilience of FBFL's self-organizing hierarchical architecture against server failures.

Reinforcement learning (RL) algorithms show promise in robotics and multi-agent systems but often suffer from low sample efficiency. While methods like SHAC leverage differentiable simulators to improve efficiency, they are limited to specific settings: they require fully differentiable environments, including transition and reward functions, and have primarily been demonstrated in single-agent scenarios. To overcome these limitations, we introduce SHAC++, a novel framework inspired by SHAC. SHAC++ removes the need for differentiable simulator components by using neural networks to approximate the required gradients, training these networks alongside the standard policy and value networks. This enables the core SHAC approach to be applied in both non-differentiable and multi-agent environments. We evaluate SHAC++ on challenging multi-agent tasks from the VMAS suite, comparing it against SHAC (where applicable) and PPO, a standard algorithm for non-differentiable settings. Our results demonstrate that SHAC++ significantly outperforms PPO in both single- and multi-agent scenarios. Furthermore, in differentiable environments where SHAC operates, SHAC++ achieves comparable performance despite lacking direct access to simulator gradients, thus successfully extending SHACs benefits to a broader class of problems. The full implementation is openly available at https://github.com/f14-bertolotti/shacpp.

Extending BDI agents with the ability to autonomously generate plans has long been a goal in the field of cognitive agent engineering to enhance their adaptability. Recent advances in GenAI are now opening new possibilities for plan generation, by leveraging the natural-language understanding, mean-end reasoning, and abstraction capabilities of LLMs. In this paper, we investigate the integration of GenAI-based plan generation into AgentSpeak(L) agents, and we analyse the implications of transferring knowledge between the LLM and the BDI agent, for the sake of dynamic plan generation. We propose a coherent framework where AgentSpeak(L) is extended with plan generation, and we model the boundaries of the generative process. We prototype our framework via the JaKtA BDI agent technology, and we methodologically assess the quality of the plans generated by LLMs of different sorts.

Federated Learning offers privacy-preserving collaborative intelligence but struggles to meet the sustainability demands of emerging IoT ecosystems necessary for Society 5.0—a human-centered technological future balancing social advancement with environmental responsibility. The excessive communication bandwidth and computational resources required by traditional FL approaches make them environmentally unsustainable at scale, creating a fundamental conflict with green AI principles as billions of resource-constrained devices attempt to participate. To this end, we introduce Sparse Proximity-based Self-Federated Learning (SParSeFuL), a resource-aware approach that bridges this gap by combining aggregate computing for self-organization with neural network sparsification to reduce energy and bandwidth consumption.

Swarm behaviour engineering is an area of research that seeks to investigate methods and techniques for coordinating computation and action within groups of simple agents to achieve complex global goals like pattern formation, collective movement, clustering, and distributed sensing. Despite recent progress in the analysis and engineering of swarms (of drones, robots, vehicles), there is still a need for general design and implementation methods and tools that can be used to define complex swarm behaviour in a principled way. To contribute to this quest, this article proposes a new field-based coordination approach, called MacroSwarm, to design and program swarm behaviour in terms of reusable and fully composable functional blocks embedding collective computation and coordination. Based on the macroprogramming paradigm of aggregate computing, MacroSwarm builds on the idea of expressing each swarm behaviour block as a pure function, mapping sensing fields into actuation goal fields, e.g., including movement vectors. In order to demonstrate the expressiveness, compositionality, and practicality of MacroSwarm as a framework for swarm programming, we perform a variety of simulations covering common patterns of flocking, pattern formation, and collective decision-making. The implications of the inherent self-stabilisation properties of field-based computations in MacroSwarm are discussed, which formally guarantee some resilience properties and guided the design of the library.

Large language models (LLMs) have transformed software engineering, particularly in code generation, where they assist developers in writing functions or entire programs. However, code generation remains challenging when the target domain is complex, as is the case with Internet of Things (IoT) systems. The challenge lies in capturing the entire system behavior within a single specification. developers often model only a subset of the system’s functionality, focusing primarily on individual device behavior or data processing aspects, which may not address the core challenges of IoT, such as large-scale distributed coordination and emergent behavior. To address this, macroprogramming paradigms have been proposed as a means to specify the collective behavior of IoT systems more holistically. Among these approaches, aggregate computing stands out for its ability to express system-wide properties through a top-down, global-to-local perspective. Despite its potential, the adoption of aggregate computing remains limited due to the complexity of writing and maintaining such programs. To overcome these barriers, we propose a language-based approach based on macroprogramming that leverages LLMs for IoT code generation. Specifically, we employ the in-context learning capabilities of LLMs, guiding them to generate code based on an aggregate computing abstraction. This creates code that reflects system-wide properties and frees programmers from writing low-level code by letting them specify desired global properties in natural language. The LLM then translates these specifications into executable code, thus facilitating the development of collective intelligence applications in IoT systems.

Today’s distributed and pervasive computing addresses large-scale cyber-physical ecosystems, characterised by dense and large networks of devices capable of computation, communication and interaction with the environment and people. While most research focuses on treating these systems as ‘composites’ (i.e., heterogeneous functional complexes), recent developments in fields such as self-organising systems and swarm robotics have opened up a complementary perspective: treating systems as ‘collectives’ (i.e., uniform, collaborative and self-organising groups of entities). This article explores the motivations, state of the art and implications of this ‘collective computing paradigm’ in software engineering. In particular, it discusses its peculiar challenges, implied by characteristics like distribution, situatedness, large scale and cooperative nature. These challenges outline significant directions for future research in software engineering, touching on aspects such as macro-programming, collective intelligence, self-adaptive middleware, learning/synthesis of collective behaviour, human involvement, safety and security in collective cyber-physical ecosystems.

Recent advancements in multi-agent reinforcement learning led to systems in which large groups of agents work together to learn shared policies and achieve collective behavior. This approach is increasingly important for many applications, including swarm robotics, crowd sensing, and large-scale IoT networks. In fact, these systems require repeated experimentation to learn from experience: simulation becomes thus essential, as deploying and testing in real-world environments incurs in high costs and practical challenges. In response to this need, our paper introduces a simulation-based pipeline to gather the necessary experience for many-agent learning. We highlight the requirements of such pipeline and the role of simulation, presenting also a practical prototype implemented in Alchemist, a simulator designed for very large-scale systems. This pipeline provides a scalable, modular, and flexible environment for developing and testing many-agent reinforcement learning strategies.