Emerging trends are leveraging the potential of the edge-cloud continuum to foster the creation of smart services capable of adapting to the dynamic nature of modern computing landscapes. This adaptation is achievable through two primary methods: by leveraging the underlying architecture to refine machine learning algorithms, and by implementing machine learning algorithms to optimize the distribution of resources and services intelligently. This paper explores the latter approach, focusing on recent advancements in pulverized architecture, collective intelligence, and many-agent reinforcement learning systems. This novel trend, which we refer to as intelligent pulverized system (IPS), aims to create a new generation of services that can adapt to the complex and dynamic nature of the edge-cloud continuum. Our proposed learning framework integrates many-agent reinforcement learning, graph neural networks, and aggregate computing to create intelligent services tailored for this environment. We discuss the application of this framework across diferent levels of the pulverization model, illustrating its potential to enhance the adaptability and eficiency of services within the edge-cloud continuum.
Recent technological developments are fostering a computational landscape that is increasingly
articulated and complex across various levels. The historical distinction between cloud, fog,
and edge computing is becoming progressively blurred, giving rise to what is known as the
edge-cloud continuum (ECC) [
The ECC is a valuable resource for creating intelligent services that leverage recent
advancements in machine learning [
This paper proposes a new vision of intelligent pulverized system (ISP) for creating a smarter
ECC by leveraging recent developments in many-agent reinforcement learning [
The rest of the paper is structured as follows: Section 2 provides an overview of the edgecloud continuum, its characteristics, and the concept of pulverization; Section 3 discusses the integration of many-agent reinforcement learning, GNNs, and aggregate computing to develop intelligent services; Section 4 details the application of intelligent collective services to various levels of pulverization, including intelligent reconfiguration, adaptive communication, and scheduling; and Section 5 summarizes our findings and outlines potential future directions for research in this area.
The rapid adoption of cloud technologies was driven by the benefit of having high availability,
and scalability of computational resources. The rise of cloud computing has led to the
proliferation of new applications involving smart devices; these applications are typically reified in
the Internet of Things (IoT) [
In this context, the highly distributed nature of such applications and the vast amount of
generated data have driven the shift from a centralized cloud computing paradigm to a more
distributed model, where the cloud is integrated with the edge. Such integration gave rise to a
new, hybrid paradigm, called edge-cloud continuum [
This new paradigm is characterized by a high level of heterogeneity in terms of devices, networks, and services. Consequently, various types of hardware devices are part of the continuum, ranging from high-end servers to wearable or embedded devices equipped with microcontrollers. Ideally, any devices equipped with a computational unit and a network connection can be part of the continuum.
This paradigm includes diverse hardware and software stacks (e.g., Linux, embedded firmware, Android Wear, Docker), and various network technologies (e.g., Ethernet, WiFi, ZigBee, LoRa, 5G/6G), making the ECC a highly heterogeneous and dynamic environment, challenging to manage in terms of resource allocation and service deployment. While the continuum ofers new possibilities to optimize the performance of applications, the complexity of the environment makes it dificult to fully exploit the full potential of the ECC, fostering the need for novel intelligent solutions.
The rapid increase in data volumes from various applications is driving the evolution of
distributed digital infrastructures for data analytics and Machine Learning (ML). Traditionally
reliant on cloud infrastructures, the need for low-latency and secure processing has shifted
some processing to IoT edge devices, finding in the ECC a prominent solution for the distributed
intelligence [
When dealing with large-scale systems, such as ECC, it is helpful to shift the focus from
individual devices to the collective system, as the behavior of the system as a whole is more
important than the behavior of individual devices. Consider, for example, a crowd congestion
alarm system. In this case, each smartphone could be part of an ECC system aimed at identifying
crowded areas and intelligently guiding the crowd to disperse, thereby avoiding emergencies.
Programming such behavior with a device-centric view is complicated because the collective
paradigm is not incorporated at that level. In this direction, a modern area of research aims to
change the programmer’s focus from the device to the aggregate. This area of research is called
macroprogramming [
The core of macroprogramming lies in identifying a collective abstraction that then becomes a first-class citizen of the programming language. Various languages have been defined in this scenario, but most of them are designed for specific applications (e.g., PyoT for IoT [ 18] and Buzz [19] for robotics). A modern approach to macroprogramming is aggregate computing [20], which is a functional top-down global-to-local paradigm that allows defining collective behaviors through the manipulation of a distributed data structure called computational fields . This macro view is then broken down into local executions of individual devices, which, by computing iteratively and continuously, achieve the specified collective behavior.
Aggregate computing has been used in the context of ECC to create additive behaviors based
on devices’ location in space [
Logical Device Physical Device Virtual Link Physical Link e goL ayL l h L P
Neighbor Devices Logical Device abstraction levels: the logical layer, the physical layer, and the infrastructure layer. On the right side, the logical device pulverized into the five subcomponents.
Pulverization [
In this context, this approach mainly targets the deployment of collective applications, where through macroprogramming, the application is designed as a composition of collective components (collective layer depicted in Figure 1). To achieve this, the pulverization model defines two main abstraction levels: the logical layer and the physical layer, as depicted in Figure 1. The former is the level at which the developer reasons about the application logic, while the latter is the level at which the specified application is deployed and executed. System Model at the logical level, the developer specifies the application as an ensemble of application-specific devices forming an arbitrary topology. An application-specific device can be “pulverized” if it can be decomposed into pulverized components representing: a set of sensors ( ), a set of actuators ( ), a state holding the device’s knowledge ( ), a communication component to interact with other devices ( ), and a behavior component defining the device’s logic ( ). The Figure 1 shows a logical device pulverized into the five subcomponents (right side of the figure).
Typically, the logical layer is composed of several (hundreds or thousands) devices forming a dynamic graph. Each logical device has a neighborhood with which it can interact. Such neighbourhoods can vary over and the way the neighborhood is defined can be applicationspecific (like proximity-based of based on physical connections). In pulverized system, the component is in charge of managing the communication between the devices, implementing the neighborhood definition and the message exchange.
Execution Model the components interact with each other to perform a MAPE-K like loop: the sensors ( ) collect data from the environment and the neighbour’s messages are received by the communication component ( ), the behavior component ( ) applies the logic taking as input the state ( ) and the data from the sensors ( ), and the neighbor’s messages. The produced output contains the new state ( ), the messages to be sent to the neighbors via the communication component ( ), and the prescriptive actions to be executed by the actuators ( ).
Notably, the flexibility of this model allows the implementation of such an interaction loop in many ways. The most common way to implement this interaction is via a round-based execution model, where each component at fixed intervals sends and/or receives messages from the other components. However, more complex implementation can be devised, like a pure reactive model where the components react to the messages received without a fixed schedule; in this case, the component leads (intelligently) the interaction loop. Another way to implement such a loop is to adopt a “best-efort” approach, where all components requiring input from the other components compute their logic against the most recent available data.
suitable for collective applications, enabling non-trivial deployments. When macroprogramming like aggregate computing [20] are used, the pulverization model naturally integrates with them, simplifying development, especially in ECC infrastructures. Otherwise, the pulverization can be exploited to design custom systems with the pulverization in mind.
Whenever an application is pulverized, a deployment mapping must be provided between the logical and the infrastructure levels. Typically, in this mapping, a logical device is typically deployed on either multiple physical devices or a single one. A logical device is often associated with an application-level physical device that needs to be managed or controlled (e.g., a sensor, a drone, or a person equipped with wearables). However, the capabilities of that physical device might not be enough to host all the components, and the pulverization might require the deployment of the components on diferent physical devices, namely infrastructure-level devices. The main advantage of pulverization is enabling many deployments without afecting or changing the application logic. Thanks to this feature, a system can be deployed on arbitrary infrastructural devices as long as they provide the required capabilities to host the components (for example, a sensor component can be executed only on devices hosting the appropriate sensors, and the behavior component can be allocated on that host having suficient computational power). In this sense, the ECC can be exploited to opportunistically allocate the components making possible deployments otherwise impossible.
The emergence of the edge-cloud continuum ofers significant potential for the development of new intelligent systems, particularly for applications that rely on machine learning techniques. In the following, we provide the current state of the art in the field of machine learning for the edge-cloud continuum.
ECC for ML Applications ECC has attracted significant attention from the ML community:
highly distributed networks composed of devices capable of generating a large amount of data
can provide new resources to enhance the quality of ML models. However, these devices often
have limited computing resources and latency constraints that prevent both local learning
and ofloading learning tasks to cloud servers. Conversely, the ECC provides a great platform
with edge servers that add computational resources close to where the data is generated. In
recent years, several studies in the literature have proposed leveraging these new resources,
for instance: i) Real-time video streaming analysis for applications such as trafic control,
surveillance, security, and real-time object detection [
Machine Learning for ECC machine learning can be exploited to optimize the deployment of
services in the ECC, since leveraging its potential in real-life scenarios is a non-trivial task. The
devices are heterogeneous and have multiple constraints (e.g., energy, latency, computational
power). For this reason, it is essential to adapt the deployment dynamically and
opportunistically. In the literature, several approaches based on heuristics and meta-heuristics have been
proposed [
The pulverization model proposes logical systems in which a series of logical entities form a dynamic graph that exposes the following properties: • large scale: an ECC system can be extensively scaled to encompass thousands of devices; • locality: edge devices are spatially located, and their behavior may depend on their location; • partial observability: edge devices do not have a perception of the entire collective but can perceive a certain neighborhood or aggregated information; • heterogeneity: devices belonging to ECC are highly heterogeneous due to their diverse nature.
Applying standard supervised learning techniques to ECC services is challenging because
it is dificult to determine the correct behavior a priori, given the highly dynamic nature of
these systems. Therefore, considering these properties, we argue that a combination of
manyagent reinforcement learning [
In the following, we introduce both many-agent reinforcement learning and graph neural networks, and then discuss the proposed algorithm for developing intelligent services for ECC.
Many-Agent Reinforcement Learning is an extension of reinforcement learning in which,
instead of having a single learning agent, there is an entire family of intelligent agents that learn
concurrently. They are referred to as “many-agent” to distinguish them from “multi-agent”,
as the number of devices can be extremely large, potentially involving thousands of devices.
Formally, a many-agent system can be modeled through a family of agent A = (, , , ℛ, )
that lives and interact in an environment ℰ = (, A, , ) [
Where the environment ℰ is defined by: • is the fixed population of agents. • A is the agent prototype governing each agent in . • : × × →
yielding a collective reward. • : → is the global observation model.
R is the global transition function influenced by agent actions,
= ( ()),
+1 = (, )
At any given time , the system can be represented as a graph = ( , ), where is
constructed from a neighborhood relationship. Each node has an associated local observation
serving as input for a GNN, as demonstrated in previous works [
The process involves three main steps in each layer of the GNN:
Graph Neural Network is a novel neural network model designed to process
graphstructured data [
︁) a() = ⨁︁ (︁ ()
{m() : ∈ ()}︁) h() = () (︁ h(− 1), a())︁ where m() is the message from node to node at layer , ⨁︀ denotes the aggregation function, and () is the update function. Initially, ℎ0 is set to the node’s feature vector . GNNS enables the efective processing of graph-structured data by iteratively updating node embeddings, capturing the local graph structure around each node. This formulation facilitates the application of GNNs in various tasks within the ECC, where the spatial relationships between devices are critical.
GNN ( ) = {h() : ∈ , ∈ N} Where is the graph with features for each node ∈ , formally: = (, , { : ∈ }). By leveraging the unique capabilities of GNNs, it is possible to develop more sophisticated and adaptive services that can dynamically respond to the complex and distributed nature of the ECC. (1) (2) (3) (4)
In this section, we discuss an approach for performing many-agent reinforcement learning
leveraging GNN in pulverized systems. In this context, as in similar many-agent scenarios, we
apply the pattern known as centralized learning and distributed execution [
Learning dynamics We base our approach on the model of pulverization, learning under the assumption that there exists a set of components that can act according to local logics – here, we are not concerned with the type of actions. Specifically, as described in Algorithm 1, for each time step , a graph represents the connectivity between devices. Each node in the graph corresponds to a local device, and edges represent the communication or influence between devices. Each node ∈ , has an associated observation creating a decorated graph that represents. This same graph can be passed to a macro program (e.g., aggregate computing) to encode global system information (e.g., areas of high consumption in the case of energy distribution, areas of the system more allocated for task distribution). The macro program aggregates local information to provide a global perspective, which is crucial for the GNN to make informed decisions. Formally, an evaluation of a macro program with a graph produces a new graph , where for each node, associate the previous local state and the evolution of the macro program: = (, ()). This graph is then passed to a GNN that will compute the actions a ∈ to be taken. These actions will be executed in the environment (i.e., the various logical components will execute what they need to), transitioning to a new collective graph +1 and obtaining a reinforcement signal R . The reinforcement signal R can be split into local and global components. The local component is derived from individual device metrics (e.g., battery consumption), while the global component is computed from aggregate metrics (e.g., average consumption in a region) that can be also computed by another macro program R.
Algorithm 1 GNN-Based many-agent reinforcement learning in ECC
1: Initialize: Local device observations o0
2: for each time step do
3: Create decorated graph with observations o
4: Apply macro program to to produce aggregate observations
5: Input into GNN to compute actions a ∈
6: Execute actions a in the environment
7: Transition to new graph +1 and obtain reinforcement signal R
8: Calculate local and collective reinforcement signals
9: Update GNN with new graph +1, observations o+1, and reinforcement signals R
10: end for
Implementation discussion This section proposes some hints for the future concrete
implementation of the algorithm described above and in Algorithm 1. First, it is worth noting
that the proposed solution is completely agnostic to the choosen many-agent reinforcement
learning algorithm. The only constraint is that such algorithm must support the centralized
learning and distributed execution model. On the one hand, a classic approach is to implement
the DQN algorithm [
In this section, we explore how the concept of intelligent collective services can be applied to various levels of pulverization, building upon the proposed model to enhance system eficiency and adaptability. In particular, in the following, we focus on three main aspects: (i) reconfiguration: how reconfiguration policies can be used to optimize the deployment of pulverized components at runtime; (ii) communication: how communication protocols can be learned to optimize the exchange of information between devices; and (iii) scheduling: how adaptive scheduling policies can be used to optimize the execution of pulverized components.
Discussion In the ECC, reconfiguration is a key component. Specifically, with pulverization, reconfiguration allows for the ofloading of one or more components of a logical device (right side of Figure 1) from one host to another to meet certain constraints. These constraints can be expressed through reconfiguration rules, which can be either local (e.g., the host’s battery drops below a certain threshold) or global (e.g., defined via aggregate computing) to preserve global coherence and prevent oscillatory conditions. While these approaches can be efective in simple scenarios, they have limitations in more complex situations: (i) they can only represent relatively simple rules; (ii) it is challenging to define all rules a priori, as they can be numerous and complex; and (iii) the rules are fixed, so if the system changes over time, it cannot adapt. Scheduling
Smart Communication Intelligent Components
Reconfiguration Intelligent Scheduling manage the intelligent execution of the behavior, Smart Communication supports the component in eficient communication and neighborhood definition, and Intelligent Components Reconfiguration manage the Intelligent and opportunistic relocation of the pulverized components, improving the system’s performance.
Vision
we believe that an interesting direction is to learn these rules through the proposed
many-agent reinforcement learning approach. Specifically, using online reinforcement learning
techniques can help manage potential changes or specific cases that were not captured
beforehand. In the literature, some works have attempted to explore this field [
Discussion
in collective systems, communication represents a crucial aspect: thanks to device communication and coordination, a global common goal can be achieved. In this sense, the component of the pulverization model is responsible for managing the neighborhoodbased communication between devices. For this reason, understanding what, when, and with whom communicate is crucial for efective and eficient coordination. Consequently, as shown in Figure 2, supporting the component with intelligent communication can be a key aspect to improve the system performance.
Learning communication protocols is a well-known problem in the literature. Initially, approaches based on heuristics and meta-heuristics were proposed [56, 57]. However, they often fail to guarantee scalability and adaptability over time, which are essential qualities for systems operating in dynamic and large-scale environments. To overcome these limitations, there has been a significant shift towards utilizing multi-agent reinforcement learning techniques. MARL has shown promise in addressing the complexities associated with learning and optimizing communication protocols among multiple agents [58, 59]. In addition to MARL, Graph Neural Networks have been employed to capture relationships between neighboring agents [60, 61]. Vision we believe the proposed many-agent reinforcement learning approach, combined with GNNs, holds great promise for learning communication protocols in the context of pulverized systems. This approach allows for:
2. optimizing the set of neighbors to which a message is sent at a given time step;
Thus, avoiding large bandwidth consumption and energy waste for individual devices.
Discussion in the pulverization model, no fixed scheduling policy is generally predefined for calculating the new state (i.e., executing the behavior). This approach allows developers considerable flexibility in choosing how and when to execute the primary behavior. The scheduling policy must be adaptable to the underlying infrastructure layer. For instance, when computations are entirely ofloaded to the cloud, there are no significant power constraints. In contrast, when computations are performed on mobile devices like smartphones, power consumption becomes a critical factor.
Beyond simple local rules (e.g., reducing evaluation frequency when battery power is low), scheduling may also be influenced by the collective results of ongoing computations. For example, in a crowd scenario, if the situation becomes less crowded, the overall frequency of evaluations may be reduced. Early work in this area, such as programmable distributed scheduling leveraging aggregate computing [62], involved defining scheduling rules based on the collective outcome of computations. However, these approaches assumed a fixed scheduling policy that did not adapt to changing environmental dynamics. Recent studies [23] have shown that simple variations of Q-learning can improve collective computation by converging more rapidly to collective structures. However, these methods relied on centralized learning and Q-tables, making them unsuitable for scaling to the complexity of diverse scenarios. Vision our vision of embracing many-agent reinforcement learning and graph networks ofers several advantages: 1. creating distributed global scheduling independent of the number of devices; 2. developing distributed policies influenced by global information or larger neighborhoods; 3. enabling more complex scheduling functions using neural networks instead of simple tables.
We believe this is a promising direction, as recent work has successfully applied this approach to specific task allocation problems [ 63]. Applying it to the pulverization model would enable its use in various collaborative scenarios, opening the possibility of creating services that intelligently optimize certain Quality of Service (QoS) metrics based on the collective layer proposed by the model.
Our approach comprehensively addresses the challenge of deploying and dynamically reconfiguring applications in the ECC injecting intelligence in these processes (cf. Section 4). Typically, application scenarios in the context of the IoT, edge computing, and swarm robotics can take advantages by their deployment in infrastructures like the ECC, improving both functional and non-functional aspects.
For instance, in smart city and wearable technology scenarios, our system ofers a dual benefit: extending battery life and minimizing the overall power consumption of deployed systems. Intelligent reconfiguration policies can be automatically devised and inferred to better relocate the component’s execution over the infrastructure, extending the device’s battery life and reducing the 2 of the system, otherwise dificult or even impossible with traditional approaches like optimization algorithm or rule-based systems (cf. Section 4.1). Similarly, determining the optimal execution policy for each component involves a complex interplay of factors, including the target device, environmental conditions, and specific application constraints. All these aspects may (and usually do) change frequently over time making it dificult to predict a priori. In a rescue scenario, our intelligent system can dynamically adapt to the emergency by increasing the computational frequency of the nearby devices, providing more updated status about the emergency conditions, while reducing the computational frequency on the farthest devices not close to the hot spot (cf. Section 4.3). Additionally, via the proposed approach, intelligent communication patterns can be automatically envisioned determining where the communication should occur (i.e., the physical place where the communication is implemented), and who this communication should involve to efectively transfer the minimal but efective information for the rescuers to promptly intervene in the emergency area (cf. Section 4.2).
In this paper, we discussed a vision for creating and deploying intelligent services within the Edge-Cloud Continuum (ECC). Specifically, we proposed an idea called intelligent pulverized systems (IPS), which combines the pulverization model with graph-based networks and many-agent reinforcement learning. This solution possesses the necessary characteristics to adapt to modern ECCs, including scalability, the ability to encode collective information, and the definition of components in an architecture-agnostic manner. We believe that this approach is essential for maximizing the potential of ECCs to create opportunistic and intelligent applications.
In the near future, we plan to leverage state-of-the-art many-agent (like mean-field
reinforcement learning [
URL: https://doi.org/10.1145/1052199.1052213. doi:10.1145/1052199.1052213. [17] R. Casadei, G. Fortino, D. Pianini, W. Russo, C. Savaglio, M. Viroli, A development approach for collective opportunistic edge-of-things services, Inf. Sci. 498 (2019) 154–169. URL: https://doi.org/10.1016/j.ins.2019.05.058. doi:10.1016/J.INS.2019.05.058. [18] A. Azzara, D. Alessandrelli, S. Bocchino, M. Petracca, P. Pagano, Pyot, a macroprogramming framework for the internet of things, in: Proceedings of the 9th IEEE International Symposium on Industrial Embedded Systems, SIES 2014, Pisa, Italy, June 18-20, 2014, IEEE, 2014, pp. 96–103. URL: https://doi.org/10.1109/SIES.2014.6871193. doi:10.1109/ SIES.2014.6871193. [19] C. Pinciroli, G. Beltrame, Buzz: A programming language for robot swarms, IEEE Softw.
33 (2016) 97–100. URL: https://doi.org/10.1109/MS.2016.95. doi:10.1109/MS.2016.95. [20] J. Beal, D. Pianini, M. Viroli, Aggregate programming for the internet of things, Computer 48 (2015) 22–30. URL: https://doi.org/10.1109/MC.2015.261. doi:10.1109/MC.2015.261. [21] G. Aguzzi, M. Viroli, L. Esterle, Field-informed reinforcement learning of collective tasks with graph neural networks, in: IEEE International Conference on Autonomic Computing and Self-Organizing Systems, ACSOS 2023, Toronto, ON, Canada, September 25-29, 2023, IEEE, 2023, pp. 37–46. URL: https://doi.org/10.1109/ACSOS58161.2023.00021. doi:10.1109/ACSOS58161.2023.00021. [22] G. Aguzzi, R. Casadei, M. Viroli, Towards reinforcement learning-based aggregate computing, in: M. H. ter Beek, M. Sirjani (Eds.), Coordination Models and Languages - 24th IFIP WG 6.1 International Conference, COORDINATION 2022, Held as Part of the 17th International Federated Conference on Distributed Computing Techniques, DisCoTec 2022, Lucca, Italy, June 13-17, 2022, Proceedings, volume 13271 of Lecture Notes in Computer Science, Springer, 2022, pp. 72–91. URL: https://doi.org/10.1007/978-3-031-08143-9_5. doi:10.1007/978-3-031-08143-9\_5. [23] G. Aguzzi, R. Casadei, M. Viroli, Addressing collective computations eficiency: Towards a platform-level reinforcement learning approach, in: R. Casadei, E. D. Nitto, I. Gerostathopoulos, D. Pianini, I. Dusparic, T. Wood, P. R. Nelson, E. Pournaras, N. Bencomo, S. Götz, C. Krupitzer, C. Raibulet (Eds.), IEEE International Conference on Autonomic Computing and Self-Organizing Systems, ACSOS 2022, Virtual, CA, USA, September 19Programming Languages and Operating Systems, Virtual Event, USA, April 19-23, 2021, ACM, 2021, pp. 135–151. URL: https://doi.org/10.1145/3445814.3446700. doi:10.1145/ 3445814.3446700. [56] C. V. Goldman, J. S. Rosenschein, Emergent coordination through the use of cooperative state-changing rules, in: B. Hayes-Roth, R. E. Korf (Eds.), Proceedings of the 12th National Conference on Artificial Intelligence, Seattle, WA, USA, July 31 - August 4, 1994, Volume 1, AAAI Press / The MIT Press, 1994, pp. 408–413. URL: http://www.aaai.org/Library/AAAI/ 1994/aaai94-062.php. [57] C. V. Goldman, S. Zilberstein, Optimizing information exchange in cooperative multiagent systems, in: The Second International Joint Conference on Autonomous Agents & Multiagent Systems, AAMAS 2003, July 14-18, 2003, Melbourne, Victoria, Australia, Proceedings, ACM, 2003, pp. 137–144. URL: https://doi.org/10.1145/860575.860598. doi:10. 1145/860575.860598. [58] C. Zhu, M. Dastani, S. Wang, A survey of multi-agent deep reinforcement learning with communication, Auton. Agents Multi Agent Syst. 38 (2024) 4. URL: https://doi.org/10.1007/ s10458-023-09633-6. doi:10.1007/S10458-023-09633-6. [59] J. N. Foerster, Y. M. Assael, N. de Freitas, S. Whiteson, Learning to communicate with deep multi-agent reinforcement learning, in: D. D. Lee, M. Sugiyama, U. von Luxburg, I. Guyon, R. Garnett (Eds.), Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, 2016, pp. 2137–2145. URL: https://proceedings.neurips.cc/paper/2016/ hash/c7635bfd99248a2cdef8249ef7bfbef4-Abstract.html. [60] A. Agarwal, S. Kumar, K. P. Sycara, M. Lewis, Learning transferable cooperative behavior in multi-agent teams, in: A. E. F. Seghrouchni, G. Sukthankar, B. An, N. Yorke-Smith (Eds.), Proceedings of the 19th International Conference on Autonomous Agents and Multiagent Systems, AAMAS ’20, Auckland, New Zealand, May 9-13, 2020, International Foundation for Autonomous Agents and Multiagent Systems, 2020, pp. 1741–1743. URL: https://dl.acm.org/doi/10.5555/3398761.3398967. doi:10.5555/3398761.3398967. [61] J. Jiang, C. Dun, T. Huang, Z. Lu, Graph convolutional reinforcement learning, in: 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020, OpenReview.net, 2020. URL: https://openreview.net/forum?id= HkxdQkSYDB. [62] D. Pianini, R. Casadei, M. Viroli, S. Mariani, F. Zambonelli, Time-fluid field-based coordination through programmable distributed schedulers, Log. Methods Comput. Sci. 17 (2021).
URL: https://doi.org/10.46298/lmcs-17(4:13)2021. doi:10.46298/LMCS-17(4:13)2021. [63] C. Jian, Z. Pan, L. Bao, M. Zhang, Online-learning task scheduling with gnn-rl scheduler in collaborative edge computing, Cluster Computing 27 (2023) 589–605. URL: http://dx. doi.org/10.1007/s10586-022-03957-w. doi:10.1007/s10586-022-03957-w.