Abstract
Multi-agent workflows have emerged as an important execution pattern for intelligent applications, where specialized agents collaborate through dependent stages such as planning, retrieval, execution, and verification. When such workflows are deployed over edge-cloud infrastructures, scheduling becomes challenging because task dependencies, heterogeneous resource conditions, and topology-dependent communication overhead must be considered jointly. We study the problem of scheduling multi-agent workflows in edge-cloud environments and propose a graph-aware scheduling method that models workflow execution as a task graph and the underlying infrastructure as a resource graph. The method combines structure-aware task and resource representations, communication-sensitive assignment scoring, and online resource-state updates to improve task placement quality. Experiments across different workflow complexities, system scales, and dynamic operating conditions show that the proposed method achieves a favorable balance among latency, communication overhead, and execution cost, particularly in communication-sensitive and medium-to-large-scale settings. These results suggest that jointly modeling workflow structure and resource topology can improve scheduling quality for multi-agent workflow execution in heterogeneous edge-cloud environments.
1. Introduction
Recent advances in large language models (LLMs) and intelligent service pipelines have accelerated the development of multi-agent systems, where different agents collaborate to accomplish complex tasks through planning, retrieval, execution, verification, and coordination [1,2]. In many practical scenarios, such multi-agent workflows are no longer executed in centralized cloud-only environments [3]. Instead, they are increasingly deployed over edge-cloud infrastructures, where edge resources can provide lower response latency while cloud resources offer stronger computation capability. This trend makes efficient workflow scheduling a key system challenge for emerging intelligent applications [4,5,6].
The need for an edge-cloud solution arises from the heterogeneous nature of multi-agent execution itself. In an agentic workflow, different stages often have different deployment preferences. For example, planning and complex reasoning may benefit from cloud-side computational capacity, while retrieval from local data sources, tool invocation over nearby devices, privacy-sensitive preprocessing, and latency-critical verification may be better executed at the edge. Executing all stages on a nearby cloud is therefore not always sufficient: it may still incur repeated wide-area data transfer, increase tail latency for local interactions, expose sensitive intermediate data, and underutilize available edge resources. Conversely, executing the entire workflow on edge nodes alone may be infeasible because some stages require stronger computation or larger model services. The practical scheduling problem is therefore not a binary edge-only or cloud-only decision, but a fine-grained placement problem over an edge-cloud continuum, where each agent stage should be assigned according to its dependency position, resource demand, data locality, and communication relationship with other stages [3,7,8].
Compared with conventional task scheduling problems, scheduling multi-agent workflows in edge-cloud environments is particularly difficult for three reasons [6,9]. First, workflow tasks are not independent, but constrained by dependency relations that determine execution order, information flow, and intermediate data transfer [9,10]. Second, the tasks represent functionally different agent stages rather than homogeneous computational jobs. A planner, a retriever, a tool-use agent, and a verifier may impose different requirements on computation, memory, data locality, and response latency. Third, edge-cloud resources are inherently heterogeneous, with substantial variation in computing capacity, queue status, execution cost, and network connectivity [11,12,13,14]. Therefore, the communication cost between distributed agent stages becomes a major factor in end-to-end performance, especially when dependent stages are placed on remote or weakly connected nodes. As a result, an effective scheduler must jointly consider task dependencies, agent-stage heterogeneity, resource heterogeneity, and topology-aware communication overhead [9,10,15].
Existing scheduling methods only partially address these challenges [6,16]. Classical heuristics such as list-based or heterogeneous earliest finish time (HEFT)-style schedulers are effective for general workflow execution, but they are often limited in handling dynamic and communication-sensitive edge-cloud conditions [17,18]. Learning-based methods improve adaptability, yet many of them rely on flat feature representations and do not explicitly exploit the structural information of workflow dependencies and resource topology [6,19]. This limitation is particularly important for multi-agent workflows, where the quality of a scheduling decision depends not only on local task-resource matching, but also on how the task is positioned in the workflow graph and how the assigned node is positioned in the underlying communication network [20,21].
To address this problem, we propose a graph scheduling framework for multi-agent workflows in edge-cloud environments. The core idea is to model both workflow dependencies and resource connectivity as graph-structured information and incorporate these structures into the scheduling process. Specifically, we represent a multi-agent workflow as a directed acyclic graph (DAG) of task dependencies and model the edge-cloud environment as a resource graph with node- and link-level attributes. Based on these representations, our method computes graph-aware scheduling scores that jointly consider execution efficiency, communication overhead, and resource cost, while dynamically updating node states during scheduling. In this way, the proposed method is able to better balance latency, communication efficiency, and execution cost under heterogeneous and dynamic conditions. Figure 1 illustrates the coupling between workflow dependencies, resource topology, and task assignment in the considered edge-cloud setting.
Figure 1.
System model of multi-agent workflow scheduling in edge-cloud environments. A workflow is represented as a task DAG, the execution substrate is represented as an edge-cloud resource graph, and task placement couples workflow dependencies with topology-dependent communication cost.
Extensive experiments on simulated edge-cloud environments with different system scales, workflow complexities, and dynamic conditions demonstrate the effectiveness of the proposed approach. The results show that our method generally outperforms or remains competitive with representative heuristic and learning-based baselines, especially in communication-sensitive settings, and achieves a favorable trade-off among latency, communication overhead, and execution cost. In particular, the proposed method exhibits clear robustness advantages in medium- and large-scale environments, as well as under bursty and congested conditions.
The proposed scheduling framework is applicable to a range of emerging intelligent service scenarios in which multi-stage agent workflows must be executed over distributed infrastructure. Representative examples include edge-assisted question answering and retrieval-augmented generation pipelines, industrial monitoring and diagnosis workflows that combine local perception with cloud-side reasoning, collaborative mobile or IoT applications with tool-use agents, and resource-aware orchestration of enterprise agent services deployed across edge and cloud sites. In such settings, workflow dependencies, communication locality, and heterogeneous resource availability jointly affect system efficiency, making graph-aware scheduling particularly relevant.
The main contributions of this work are as follows:
- We formulate multi-agent workflow scheduling in edge-cloud environments as a graph-structured decision problem that jointly captures workflow dependencies, heterogeneous resource conditions, and topology-dependent communication costs.
- We propose a graph-aware scheduling method that combines structure-aware task and resource representations, communication-sensitive assignment scoring, and online resource-state updates within a unified scheduling process.
- We conduct extensive experiments across different workflow complexities, system scales, and dynamic operating conditions, showing that the proposed method provides a more favorable trade-off among latency, communication overhead, and execution cost than representative baselines.
2. Related Work
2.1. Workflow Scheduling in Edge-Cloud Environments
Workflow scheduling has been extensively studied in cloud, edge, and geo-distributed computing systems. Existing studies mainly focus on assigning dependent tasks to heterogeneous resources under objectives such as latency minimization, cost reduction, and load balancing. Classical heuristic methods, including list-based scheduling and HEFT-style strategies, remain strong baselines due to their simplicity and efficiency [6,17]. More recently, researchers have extended workflow scheduling from conventional cloud platforms to edge-cloud and geo-distributed settings, where communication latency, resource heterogeneity, and dynamic system conditions play a much more important role [5,6].
Despite this progress, most existing workflow scheduling methods are still designed for general task graphs and infrastructure-level optimization, without explicitly considering emerging multi-agent workflows driven by intelligent service pipelines [5,19]. In particular, the execution pattern of multi-agent workflows differs from conventional DAG scheduling because tasks often correspond to functionally specialized agent stages, and communication among related subtasks becomes a critical part of the end-to-end cost [22,23]. This motivates the need for scheduling methods that are more communication-aware and structure-aware in edge-cloud environments.
2.2. Learning-Based and Graph-Based Scheduling Methods
To overcome the limitations of hand-crafted heuristics, learning-based scheduling methods have recently attracted increasing attention. Reinforcement learning and deep reinforcement learning have been widely explored for workflow scheduling and resource allocation in cloud and edge systems, offering improved adaptability under dynamic environments [6,24]. In parallel, graph-based learning has emerged as a promising direction, since both task dependencies and resource connectivity naturally exhibit graph structures. Representative efforts have shown that graph neural networks can capture structural information more effectively than flat feature representations for distributed scheduling and mapping problems [25,26].
However, existing graph-based schedulers mainly target scientific workflows, HPC systems, or generic distributed computing scenarios [25,27,28]. Their objective is often makespan reduction or throughput optimization, and they are not designed for multi-agent workflows deployed over edge-cloud infrastructures. In addition, many prior methods do not explicitly emphasize communication-sensitive orchestration under dynamic edge-cloud conditions [5,29]. Our work differs from these studies by focusing on graph scheduling for multi-agent workflows, where the scheduler must jointly consider workflow dependencies, topology-aware communication overhead, and evolving resource states.
2.3. LLM-Based Multi-Agent Systems in Distributed Environments
With the rapid development of large language models, multi-agent systems have become an important paradigm for decomposing complex tasks into interacting roles such as planning, retrieval, execution, verification, and coordination [2,30]. Recent studies have explored LLM-based multi-agent systems in a variety of domains, including software engineering, complex event processing, and edge/cloud orchestration [1,31,32]. These works show that multi-agent pipelines can improve modularity, scalability, and problem-solving capability, but they also introduce new system-level challenges related to deployment, communication, and coordination.
Meanwhile, early efforts have begun to consider LLM or multi-agent execution in edge-cloud environments, where resource constraints and communication heterogeneity become more prominent [3,8]. Nevertheless, most of these studies focus on system architecture, orchestration frameworks, or application demonstrations rather than workflow scheduling itself. Compared with prior work, our study focuses specifically on the scheduling problem of multi-agent workflows in edge-cloud environments and investigates how graph-aware modeling can improve latency, communication efficiency, and execution cost under heterogeneous and dynamic conditions.
3. Problem Definition
In this work, we study the scheduling of multi-agent workflows in edge-cloud environments. A user request is modeled as a workflow composed of multiple interdependent agent stages. Each stage corresponds to an invocation of a functional agent or agent service, such as a planner, retriever, tool-use agent, executor, verifier, or summarizer. These agents define the logical roles and dependency relations of the workflow, whereas edge and cloud nodes provide the physical execution resources on which the corresponding stages are deployed. Therefore, the role of the scheduler is not to design the agents themselves, but to determine where each agent-stage task should be executed under resource and network constraints. The goal is to improve workflow efficiency by assigning interdependent agent stages to heterogeneous edge-cloud resources while accounting for computation demand, data transfer, and communication locality.
3.1. Multi-Agent Workflow Model
We represent a multi-agent workflow as a DAG
where denotes the set of agent-stage tasks, and denotes the dependency relations among them. Each node represents one executable stage of a multi-agent workflow rather than a physical machine. For example, may correspond to a planning agent invocation, a retrieval stage over local or remote data, a tool invocation, a domain-specific execution stage, a verification agent, or a summarization stage. An edge indicates that stage can start only after stage has been completed and its output has become available.
Each agent-stage task is associated with a feature vector describing its execution requirement, including computation demand, memory demand, input/output data size, latency sensitivity, and the type of agent stage. These features characterize the workload imposed by the corresponding agent invocation and affect its suitability for different execution nodes. For instance, a retrieval stage may be more sensitive to data locality and communication delay, whereas a reasoning or summarization stage may require stronger computation capacity. In addition, the position of a task in the workflow graph also influences scheduling decisions, since upstream stages may affect the execution readiness of downstream stages and the placement of related stages may introduce additional communication overhead.
We denote by and the sets of predecessor and successor tasks of , respectively. A task becomes ready only when all tasks in have finished execution. This dependency-aware execution process distinguishes workflow scheduling from conventional independent-task resource allocation. The DAG assumption is used to model request-level agent workflows with finite execution stages and explicit precedence relations. This covers many practical agentic pipelines, such as plan–retrieve–execute–verify workflows. Cyclic or long-running conversational agent loops can be approximated by unrolling a bounded number of iterations into DAG segments, while fully cyclic workflow scheduling is beyond the scope of this study.
3.2. Edge-Cloud Resource Model
We model the edge-cloud environment as a resource graph
where denotes the set of computing nodes, and denotes the communication links between nodes. Each node may correspond to an edge server or a cloud server.
Each resource node is associated with a feature vector including available CPU capacity, memory capacity, queue length, and execution cost. Each communication link is associated with network attributes such as transmission latency and bandwidth. These node- and link-level attributes jointly determine the cost and feasibility of executing workflow tasks on distributed resources.
Unlike a centralized homogeneous cluster, an edge-cloud environment exhibits both resource heterogeneity and topology-aware communication variation [33]. As a result, a task assignment that is locally feasible may still be globally inefficient if it causes excessive cross-node communication delay or places communication-intensive tasks on poorly connected nodes.
3.3. Task Assignment and Scheduling Decision
Given a workflow graph and a resource graph , the scheduling problem aims to derive an assignment function
which maps each workflow task to a resource node for execution.
A feasible assignment should satisfy three constraints. First, the resource demand of each assigned task cannot exceed the available capacity of its target node. Second, a task can start only after all predecessor tasks in the workflow graph have finished. Third, when two dependent tasks are assigned to different nodes, additional communication delay is incurred according to the corresponding path in the resource graph. For each task , we denote by the feasible candidate set of resource nodes that satisfy its minimum execution requirements. The scheduler determines one target node for each task. The complete scheduling result is therefore a task-to-resource assignment over all workflow tasks.
3.4. Optimization Objective
The goal of scheduling is to find an assignment function that minimizes the overall workflow execution cost while maintaining high task execution efficiency. In particular, we consider three main objectives: workflow completion latency, communication overhead, and execution cost. The optimization problem is formulated as
where denotes the end-to-end workflow latency, denotes the communication overhead caused by cross-node task dependencies, and denotes the execution cost. Here, , , and are non-negative coefficients that control the trade-off among different objectives.
More specifically, the latency term includes both computation delay and dependency-aware waiting time under the workflow execution order. The communication term captures the data transfer overhead caused by assigning dependent tasks to different resource nodes. The cost term reflects the usage cost of selected edge or cloud resources. In addition to the optimization objective above, task completion rate and service-level agreement (SLA) violation ratio are used as evaluation metrics in the experiments.
The key challenge of this problem lies in the fact that both the workflow and the resource environment exhibit inherent graph structures. Effective scheduling therefore requires jointly considering task dependencies, node capacities, and topology-aware communication costs, rather than relying only on isolated task or node features. This motivates the design of a graph scheduling method that explicitly models structural information on both the workflow side and the resource side.
4. Method
We propose an online graph-aware scheduler for executing multi-agent workflows over heterogeneous edge-cloud infrastructures. The central design principle is that scheduling decisions should be made with respect to two coupled graph structures: the workflow graph, which specifies precedence constraints and inter-task data dependencies, and the resource graph, which specifies execution capability and communication locality. A scheduler that reasons only about local task–node fit may overlook downstream communication penalties, while a scheduler that focuses only on topology may ignore instantaneous resource contention. Our method is designed to balance both aspects within a unified assignment process.
The proposed method should be understood as a structure-aware online scheduling heuristic rather than an offline global optimizer. Finding a globally optimal assignment for a dependent workflow over heterogeneous resources is generally computationally expensive, especially when communication costs and dynamic resource states are considered. In practical edge-cloud systems, resource states such as queue length, available capacity, and link conditions may evolve during scheduling. Therefore, instead of enumerating all possible task-to-resource mappings, our scheduler assigns ready tasks sequentially in a dependency-consistent order and updates the resource state after each assignment. This design improves responsiveness to dynamic operating conditions, although it does not provide a theoretical guarantee of global optimality.
Formally, the scheduler takes as input a workflow DAG and a resource graph , and produces a task-to-resource mapping . The method proceeds in four stages. First, it derives structure-aware representations of workflow tasks and resource nodes. Second, for each feasible task–resource pair, it constructs pairwise compatibility features that reflect execution feasibility, communication implications, and current resource conditions. Third, it computes an assignment score by combining structure-aware representations with explicit scheduling-oriented cost terms and a lightweight correction term. Finally, it generates the schedule sequentially in a dependency-consistent manner while updating resource states online after each assignment. The resulting procedure is therefore an online constructive scheduler: it progressively builds a feasible task-to-resource mapping rather than solving a full offline combinatorial optimization problem over all assignments at once. Figure 2 provides an overview of the proposed scheduling pipeline and the information flow across its main components.
Figure 2.
Overview of the proposed graph-aware scheduling framework. The method jointly models workflow structure and resource topology, computes communication-sensitive assignment scores, and performs online task scheduling with dynamic resource-state updates.
4.1. Structure-Aware Representation of Workflows and Resources
The workflow is modeled as a directed acyclic graph
where each node denotes a task and each directed edge indicates that cannot start before finishes. Each task is associated with an attribute vector
which may include computation demand, memory demand, input/output data size, and latency sensitivity. The execution environment is modeled as a resource graph
where each node denotes an execution node and each edge denotes a communication link. Node attributes are represented by
including available compute capacity, available memory, queue length, and execution price. Each link is associated with topology-dependent communication attributes such as latency and bandwidth. We encode the workflow graph and the resource graph separately using lightweight message-passing encoders. For task node , its representation is computed as
where denotes the neighborhood of in the workflow graph. Likewise, for resource node ,
In the proposed framework, and are used to capture structure-aware task and resource representations, so that the scheduler can account for both workflow-side dependency context and infrastructure-side topology context. In particular, reflects the structural role of task within the workflow graph, while reflects the operational and topological position of node within the edge-cloud substrate. These structure-aware representations are incorporated into the assignment-scoring process together with explicit execution, communication, and cost-related terms.
4.2. Feasible Candidate Set and Pairwise Compatibility
For each task , the scheduler first identifies its feasible candidate set
This filtering step excludes inadmissible assignments and reduces the effective search space during scheduling. For every feasible pair with , we define a compatibility vector
where denotes the current resource state at scheduling step t. Here, is a deterministic feature-construction function rather than a separate learned policy. It summarizes the assignment-specific effect of placing agent-stage task on resource node under the current system state. In our implementation, the compatibility vector is constructed as
where and denote the residual CPU and memory margins after assigning to , denotes the normalized queue length of node , denotes the estimated execution delay, denotes the predecessor-induced communication delay, denotes the estimated execution cost, denotes the type indicator of the agent stage, and denotes the type indicator of the resource node, such as edge or cloud.
Unlike the node-level embeddings and , which encode structural context, captures assignment-specific information under the current operating condition. In particular, it summarizes the immediate consequence of assigning task to node , including the residual capacity margin after assignment, the estimated execution time on the candidate node, the transfer delay induced by already assigned predecessor tasks, the execution price associated with using , and the compatibility between the agent-stage type and the resource-node type.
This separation between node-level representations and pairwise compatibility is intentional. The graph encoders provide structure-aware representations of tasks and resources, whereas captures the local operational effect of a specific task–node assignment under the current system state.
4.3. Decomposed Assignment Score
A central design choice of our method is to avoid treating scheduling as a purely black-box classification problem. Instead of directly feeding concatenated features into a predictor and interpreting its output as a scheduling score, we define the score as a structured combination of interpretable components.
For a feasible assignment pair , we first compute three normalized quantities:
which represent estimated execution time, communication overhead, and monetary or system cost, respectively. These quantities are all defined so that smaller values are preferred. The execution component is estimated as
where denotes the effective computation demand of task and denotes the currently available service capacity of node . In practice, this term may be augmented with queueing delay. The communication component is defined over the predecessor set of :
where denotes the data volume transferred from predecessor to , denotes the available bandwidth between the hosting node of and , and denotes the corresponding link latency. This term penalizes assignments that separate strongly dependent tasks across poorly connected nodes. The resource-cost component is defined as
where denotes the unit execution price of node .
These explicit terms are combined with a lightweight structural correction term. Specifically, we form the joint representation
and compute
The function maps the normalized joint feature vector to a bounded residual score. In the implementation, is used as a lightweight residual scorer over the concatenated structural and pairwise features,
where denotes feature normalization within the current scheduling instance, and are fixed residual-scoring parameters, and bounds the correction term to prevent it from dominating the explicit execution, communication, and cost components. Thus, does not replace the decomposed scheduling objective. Instead, it provides a small correction that captures interactions among workflow-side structural context, resource-side topological context, and assignment-specific compatibility signals that are not fully represented by the three explicit scalar terms alone.
The final assignment score is defined as
where , , and are normalized versions of the three explicit components, and are trade-off coefficients. Here, , , , and control the relative importance of the execution-related term, communication-related term, cost-related term, and structure-aware correction term, respectively. Since is bounded, the correction term has a residual effect controlled by and cannot arbitrarily override the explicit cost terms. A larger value of indicates a more desirable assignment.
This formulation has two advantages. First, it preserves interpretability, since the contributions of execution delay, communication overhead, and resource cost remain explicit. Second, it allows the correction term to refine candidate ranking without turning the scheduler into a fully opaque black-box decision model. Figure 3 presents a simplified example illustrating the trade-off between local execution efficiency and dependency-aware communication efficiency. In the example, one candidate node offers faster local execution for the current task, whereas another candidate leads to lower cross-node communication cost because it is better aligned with the placement of dependency-related tasks. The example is intended to show that a communication-aware scheduler may prefer a slightly weaker local execution option when it leads to a better overall end-to-end assignment.
Figure 3.
Illustrative example of communication-aware scheduling. The left panel shows a workflow DAG. The right panel compares two candidate placements for the current task , where Edge Node 1 is hosting and the Cloud Node is hosting . Candidate A offers better local execution efficiency, whereas Candidate B leads to lower communication overhead. The example highlights the trade-off between local resource fit and communication-aware scheduling in edge-cloud workflow execution.
4.4. Online Graph Scheduling with State Updates
Scheduling is performed online in a precedence-consistent order. The scheduler progressively constructs the assignment by selecting one ready task at a time, rather than optimizing over all possible assignments simultaneously. Let be a topological ordering of the workflow graph. At step t, the scheduler selects the next ready task whose predecessors have already been assigned and completed. For each candidate , it computes the score and chooses
The assignment is then committed as
After each decision, the resource state is updated immediately. Let denote the current system state before assigning . The update operator
adjusts the available compute capacity, memory, queue occupancy, and other scheduling-relevant state variables of node . In addition, if differs from the hosting nodes of predecessor tasks, the communication statistics associated with the corresponding links are updated accordingly.
This online update mechanism is essential for realistic scheduling. Without it, the scheduler would repeatedly evaluate all later assignments against stale resource information, which can lead to pathological over-allocation of initially attractive nodes. By updating the state after each assignment, the scheduler internalizes the resource consumption caused by earlier decisions and therefore makes later decisions under progressively changing operating conditions. The complete scheduling procedure is summarized in Algorithm 1.
| Algorithm 1 Graph-Aware Scheduling for Multi-Agent Workflows |
| Require: Workflow graph , resource graph |
| Ensure: Task-to-resource assignment |
|
4.5. Complexity Analysis
The computational overhead of the proposed method consists of graph encoding and candidate evaluation. Let and denote the number of nodes and edges in the workflow graph, and let and denote the corresponding quantities in the resource graph. The graph encoding stage scales linearly with the number of message-passing operations over the two graphs and is incurred once per scheduling instance.
During scheduling, the dominant cost arises from evaluating feasible candidates. If the average feasible candidate set size is , then the candidate evaluation stage requires
score computations, excluding the one-time graph encoding cost. Since in constrained edge-cloud settings, the effective cost is substantially lower than exhaustive evaluation over the full resource pool. The method therefore remains tractable for medium-scale heterogeneous deployments while explicitly accounting for dependency structure, communication topology, and online resource-state evolution.
5. Experiments
In this section, we evaluate the effectiveness of the proposed graph scheduling method for multi-agent workflows in edge-cloud environments. The experiments evaluate three aspects of the proposed method: its overall performance relative to representative baselines, its behavior under different workflow scales and dynamic operating conditions, and the contribution of its main design components.
5.1. Experimental Setup
5.1.1. Edge-Cloud Environment
We construct a simulated edge-cloud environment with heterogeneous computing nodes and communication links. The environment contains both edge nodes and cloud nodes. Edge nodes provide lower communication latency but more limited computing resources, whereas cloud nodes offer stronger computation capability at the cost of potentially higher transmission delay and resource usage cost. To evaluate scalability, we consider three deployment scales, denoted as small, medium, and large, containing 20, 50, and 100 resource nodes, respectively. Each resource node is associated with attributes including available CPU capacity, memory capacity, queue length, and execution cost, while each communication link is characterized by bandwidth and transmission latency. These settings allow us to simulate both resource heterogeneity and topology-dependent communication overhead in edge-cloud systems [7,11]. Accordingly, the difference between simple, moderate, and complex workflows is modeled jointly by workflow size and dependency density, so that more complex workflows exhibit richer coordination and communication requirements.
5.1.2. Workflow Construction
Each multi-agent workflow is modeled as a directed acyclic graph whose nodes correspond to interdependent execution stages, such as planning, retrieval, tool invocation, verification, and summarization. Each task is associated with workload attributes including computation demand, memory demand, input/output data size, and latency sensitivity. To study the effect of workflow complexity, we generate three categories of workflows: simple workflows containing 5–7 tasks, moderate workflows containing 8–12 tasks, and complex workflows containing 13–20 tasks. The dependency structure is generated with varying edge densities so as to simulate different levels of execution coupling and communication dependency among tasks [34,35].
5.1.3. Dynamic Conditions
To evaluate scheduler robustness under changing operating conditions, we consider three dynamic settings. In the stable setting, resource availability and network conditions remain relatively steady throughout execution. In the bursty setting, tasks arrive in bursts, resulting in temporary queue growth and resource contention. In the congested setting, part of the communication topology experiences increased latency and reduced effective bandwidth. Together, these settings allow us to examine whether the proposed method remains effective when the execution environment becomes less predictable and more constrained [11,36].
5.1.4. Baselines
We compare the proposed method with several representative baselines. Round Robin assigns tasks to resource nodes in a cyclic manner without considering workflow structure or resource heterogeneity [37]. Greedy Resource-Fit assigns each task to the feasible node that provides the best local fit according to available capacity and estimated execution cost [38]. HEFT-like Scheduler is a dependency-aware heuristic that prioritizes workflow tasks and assigns them according to estimated completion time [18]. MLP-Based Scheduler uses a multilayer perceptron (MLP)-style flat feature scoring strategy without explicit graph-structure modeling [39]. Comm.-Cost-Aware Greedy is a stronger objective-aligned heuristic baseline that extends greedy assignment by jointly considering local execution suitability, predecessor communication penalty, and execution cost during candidate selection [40]. The full proposed model is denoted as Graph Scheduling. All baselines were implemented under the same simulator and evaluated on identical workflow-resource instances. While their decision principles differ, they were compared under the same execution, communication, and resource conditions to ensure a fair experimental protocol.
5.1.5. Evaluation Metrics
We evaluate all methods using four primary metrics: average latency, communication overhead, execution cost, and SLA violation ratio. Average latency measures the mean end-to-end workflow completion time. Communication overhead quantifies the total cross-node communication cost incurred during execution, and execution cost measures the overall resource usage cost. SLA violation ratio is defined as the fraction of workflows whose completion time exceeds the predefined latency threshold. Taken together, these metrics provide a comprehensive view of efficiency, robustness, and resource usage. In the performance result tables, the symbol ↓ indicates that a lower value is better.
5.1.6. Implementation Details
All experiments were implemented in Python on a Linux server with 64 CPU cores (Intel Xeon Gold 6326 @ 2.90 GHz), 755 GiB system memory, and 8 NVIDIA A800 80 GB PCIe GPUs. The software stack included Python 3.11.13, PyTorch 2.4.0+cu121, NetworkX 3.5, Pandas 2.3.3, and Matplotlib 3.10.8.
The proposed method and all baselines were evaluated within the same simulation framework. Workflow graphs and resource graphs were generated programmatically with fixed random seeds. Each reported result was averaged over 30 independent runs, and variability is reported as mean ± standard deviation unless otherwise specified. In the main experiments, system scale was varied from small to large, while workflow complexity was controlled by the number of tasks and the density of dependency edges. In the dynamic-condition experiments, bursty and congested settings were simulated by perturbing node queue lengths and communication-link conditions, respectively.
The proposed method was implemented as a graph-aware scoring-based scheduler. During scheduling, tasks were processed in dependency-consistent order, and each feasible task–node pair was evaluated using explicit execution-related, communication-related, and cost-related terms together with a lightweight structure-aware correction term. Resource states were updated immediately after each assignment to reflect the resulting changes in queue status and available capacity. The SLA latency threshold was fixed at 120 in all experiments. In addition to reporting average performance, we also computed standard deviations over repeated runs to assess result stability across different random seeds.
In the default configuration, was fixed as the reference weight for the execution-related term, while , , and controlled the relative importance of communication overhead, execution cost, and the structure-aware correction term, respectively. Unless otherwise specified, these coefficients were set to fixed default values chosen a priori rather than tuned separately for each setting. Their influence was further examined through the parameter sensitivity analysis in Section 5.6.
5.1.7. Simulation Details
Communication cost is evaluated over the resource graph rather than using direct-link assumptions only. When two dependent tasks are assigned to different nodes, the communication delay is computed based on the shortest path with respect to link latency in the resource graph. In the current simulator, path aggregation is latency-based and does not explicitly model global multi-flow bottleneck sharing; instead, communication degradation is reflected through link-level perturbations and assignment-dependent path selection.
Task execution time is estimated as a function of task demand and currently available node capacity. More specifically, execution delay is inversely related to the available service capacity of the selected node, while queue-related waiting is modeled through node queue-length penalties. Resource-state updates are applied online after each task assignment by adjusting available CPU, available memory, and queue length, so that subsequent assignments are evaluated under evolving system conditions rather than stale node states.
Dynamic conditions are simulated through controlled perturbations. In the bursty setting, a subset of resource nodes experiences increased queue lengths to emulate temporary contention and burst arrivals. In the congested setting, a subset of communication links is perturbed by increasing latency and reducing effective bandwidth, thereby creating topology-dependent communication degradation. These perturbations are applied before scheduling for a given run and remain effective throughout that scheduling instance.
Workflow generation is calibrated to reflect multi-agent execution stages such as planning, retrieval, tool invocation, execution, verification, and summarization. Different task types are associated with different ranges of computation demand, memory demand, input/output data size, and latency sensitivity. Workflow complexity is controlled by both the number of tasks and the density of dependency edges, enabling the simulator to represent execution pipelines with different levels of coupling and communication dependency.
To make the simulation configuration explicit, Table 1 summarizes the main simulator parameters, including resource-graph generation, virtual-machine attributes, network-link attributes, workflow construction, dynamic perturbations, and evaluation settings.
Table 1.
Main simulation parameters used in the edge-cloud workflow scheduling experiments. Here, denotes a uniform distribution over , and all generated quantities are expressed in simulator units unless otherwise specified.
5.2. Overall Performance Comparison
Table 2 summarizes the overall performance of all methods across different system scales and workflow complexities. The results reveal three consistent patterns.
Table 2.
Overall performance comparison under different system scales and workflow complexities. Results are reported as mean ± standard deviation over 30 independent runs. For all metrics, lower values are better. The best mean result in each row block is highlighted in bold.
First, the gap between structure-aware schedulers and weak non-structural baselines is substantial across nearly all settings. Round Robin consistently produces the worst results in both latency and communication overhead, which is expected because it ignores workflow dependencies, node heterogeneity, and communication locality altogether. Greedy Resource-Fit improves upon Round Robin by taking local resource suitability into account, but its decisions remain fundamentally myopic: it evaluates each assignment primarily from the perspective of local feasibility and immediate execution cost, without adequately accounting for the downstream communication consequences induced by task dependencies. This limitation becomes increasingly severe as workflow complexity grows.
Second, among the stronger baselines, the proposed Graph Scheduling method achieves the most favorable overall trade-off in medium- and large-scale environments, while the Comm.-Cost-Aware Greedy baseline serves as a stronger objective-aligned heuristic competitor than conventional greedy fitting. Its advantage is especially clear on communication overhead and execution cost, and in several cases this also translates into the best end-to-end latency. For example, under the medium-simple setting, Graph Scheduling improves over the MLP-based scheduler on all three main metrics, reducing average latency from 38.37 to 28.59, communication overhead from 44.84 to 32.10, and execution cost from 28.74 to 26.21. A similar trend appears in the medium-moderate and large-complex settings. At the same time, the Comm.-Cost-Aware Greedy baseline becomes the strongest non-graph baseline in several cases, such as large-simple and large-moderate, indicating that aligning the heuristic objective with communication and cost considerations substantially strengthens baseline performance. These results suggest that the proposed method is particularly effective in regimes where the scheduler must simultaneously reason about nontrivial task dependencies and a sufficiently rich communication topology.
Third, the primary strength of the proposed method lies in controlling communication-sensitive inefficiency rather than optimizing makespan alone. Compared with HEFT-like scheduling, Graph Scheduling does not always produce the lowest latency in every setting, but it more consistently reduces cross-node communication overhead and execution cost. Compared with the MLP-based scheduler, it typically achieves stronger communication efficiency and better cost-awareness while maintaining competitive or better latency in most medium-to-large settings. Compared with the Comm.-Cost-Aware Greedy baseline, the proposed method remains more robust in structurally demanding cases, particularly when communication-sensitive dependencies become more pronounced. This behavior is aligned with the design of the method: by explicitly incorporating workflow structure and resource-topology information into the assignment score, it prefers placements that preserve communication locality while remaining sensitive to current resource conditions. The resulting schedules are therefore often more balanced from a system perspective, even when a latency-oriented or partially aligned heuristic occasionally performs better on a specific instance.
A representative example of this trade-off appears in the small-complex setting, where the HEFT-like scheduler achieves lower latency than Graph Scheduling, and the Comm.-Cost-Aware Greedy baseline also remains highly competitive. This result is plausible because, in a relatively small system, the scheduling space is more constrained and a strong heuristic may benefit from aggressively favoring critical-path execution or compact local placement. Under such conditions, the benefit of full graph-aware placement is less pronounced than in larger deployments, and the scheduler may gain more from exploiting local or priority-based structure than from globally optimizing communication locality. Even so, Graph Scheduling remains competitive on the main metrics and achieves the lowest execution cost in that setting.
These results indicate that the proposed method is most beneficial when scheduling decisions must reflect both workflow-side and infrastructure-side structure. Its advantage becomes more stable as the problem moves away from small, tightly constrained instances and toward settings in which communication topology, dependency coupling, and heterogeneous resource conditions jointly shape the quality of the final schedule.
To further assess whether the observed improvements are statistically reliable and practically meaningful, we performed paired significance tests and paired effect-size analysis on two representative settings, namely medium-moderate and large-complex, by comparing the proposed Graph Scheduling method against the HEFT-like Scheduler and the MLP-Based Scheduler. We considered average latency and communication overhead as the primary comparison metrics. As shown in Table 3, the proposed method achieves statistically significant reductions in communication overhead across all four representative comparisons, with moderate to large paired effect sizes. In terms of latency, Graph Scheduling significantly outperforms the MLP-based scheduler under the medium-moderate setting and the HEFT-like scheduler under the large-complex setting, both with moderate paired effect sizes. The remaining latency comparisons show small effect sizes and no statistically significant difference, which is consistent with our broader conclusion that the main advantage of the proposed method lies in achieving a stronger overall balance, especially in communication-sensitive settings.
Table 3.
Statistical significance testing and paired effect sizes on representative settings. Reported p-values are from paired t-tests and Wilcoxon signed-rank tests over 30 paired runs. Cohen’s and Hedges’ are computed from paired differences (Graph Scheduling minus baseline); negative values indicate lower latency or communication overhead for Graph Scheduling. Bold values indicate statistical significance at the 0.05 level.
5.3. Scalability and Workflow Complexity Analysis
We next examine how the relative behavior of different schedulers changes with system scale and workflow complexity. Figure 4, Figure 5 and Figure 6 show that the benefit of graph-aware scheduling becomes more pronounced as the scheduling problem becomes structurally richer.
Figure 4.
Average latency comparison under different system scales and workflow complexities.
Figure 5.
Communication overhead comparison under different system scales and workflow complexities.
Figure 6.
Execution cost comparison under different system scales and workflow complexities.
For simple workflows, the performance gap among the stronger methods is relatively modest, particularly in medium- and large-scale environments. In these settings, the dependency structure is shallow and the number of inter-task communication events is limited, so even conventional dependency-aware or flat-feature schedulers can often identify reasonably good assignments. As a result, the advantage of explicitly modeling both workflow structure and resource topology is present but not yet dominant. Even under these easier conditions, however, Graph Scheduling remains competitive and frequently achieves lower communication overhead or lower execution cost than the stronger baselines.
The picture changes for moderate workflows. As the number of tasks increases and dependency relations become denser, scheduling quality depends less on isolated task–node fit and more on whether related tasks are placed in communication-efficient regions of the infrastructure. Under these conditions, the proposed method begins to show a clearer advantage. This is especially visible in communication overhead, where graph-aware scheduling more consistently avoids topology-unfriendly placements than both heuristic and graph-agnostic learning baselines. The latency improvement in these settings is therefore not merely a consequence of faster local execution, but of better coordination between dependency structure and resource connectivity.
The advantage becomes strongest for complex workflows, particularly in medium- and large-scale systems. In these regimes, the scheduler must handle both richer precedence coupling and a larger set of feasible placement patterns. This is precisely where graph-aware modeling becomes most useful. For example, in the medium-complex setting, Graph Scheduling substantially reduces communication overhead and execution cost relative to the HEFT-like and MLP-based baselines while remaining competitive in latency. In the large-complex setting, it achieves the best results on all three primary metrics. These results indicate that the proposed method scales more favorably as the scheduling problem becomes simultaneously more topologically complex and more resource-diverse.
An important observation is that system scale and workflow complexity do not affect scheduler behavior independently. Their interaction matters. Increasing system scale expands the placement space and amplifies the importance of communication topology, while increasing workflow complexity amplifies the number of dependency-induced coordination decisions. When both factors grow together, schedulers that rely mainly on local heuristics or flat representations become increasingly brittle. By contrast, the proposed method benefits from having explicit access to both workflow-side and infrastructure-side structure.
These scalability results indicate that the proposed scheduler is not merely competitive on a fixed benchmark configuration, but increasingly advantageous in the regimes where edge-cloud scheduling is intrinsically difficult. Its gains are most stable when task dependencies are nontrivial, candidate placements are diverse, and communication locality becomes a first-order factor in end-to-end workflow efficiency.
5.4. Robustness Under Dynamic Conditions
We further evaluate the robustness of different schedulers under three dynamic operating conditions: stable, bursty, and congested. The results in Table 4 show that the proposed method is generally more resilient to runtime variation, especially when communication conditions and instantaneous resource states have a direct influence on scheduling quality. Figure 7 and Figure 8 further visualize the latency and communication-overhead trends under these dynamic conditions.
Table 4.
Performance under dynamic conditions. Results are reported as mean ± standard deviation over 30 independent runs. For all metrics, lower values are better. The best mean result in each row block is highlighted in bold.
Figure 7.
Average latency under stable, bursty, and congested conditions.
Figure 8.
Communication overhead under stable, bursty, and congested conditions.
The clearest advantage appears in the medium-moderate and large-moderate settings. Across all three operating conditions, Graph Scheduling consistently achieves the lowest communication overhead and, in most cases, the best or near-best latency and execution cost. This pattern suggests that the proposed method adapts well when the system is large enough for topology-aware placement to matter, but not yet so constrained that the scheduler is dominated by a narrow set of unavoidable bottlenecks. In this regime, updating resource states online and explicitly accounting for communication structure both contribute directly to better placement decisions.
The benefit of the proposed method remains strong in the large-complex setting, where both workflow-side and infrastructure-side complexity are high. Across the stable, bursty, and congested conditions, Graph Scheduling consistently achieves the lowest communication overhead and execution cost, while maintaining competitive latency. In several cases, the HEFT-like scheduler still obtains lower latency because of its stronger critical-path bias, but this comes with substantially higher communication overhead and execution cost. This behavior is consistent with the intended design of the method, which emphasizes balanced communication-aware and cost-aware scheduling rather than latency minimization alone. When queue conditions fluctuate or communication links degrade, scheduling quality depends not only on static task priority but also on whether assignments remain locality-aware under evolving system conditions. The proposed scheduler is better positioned to preserve this balance because its scoring mechanism explicitly couples workflow dependencies, communication topology, and current resource state.
The medium-complex regime is more mixed and therefore particularly informative. In this setting, the HEFT-like scheduler achieves the lowest latency in some conditions, while the MLP-based scheduler occasionally yields lower communication overhead than the full model. This suggests that when the workflow is already highly coupled but the overall system scale is not yet large enough to provide abundant alternative placements, different schedulers may benefit from different biases. A latency-oriented heuristic can still gain from aggressively exploiting precedence structure, and a flatter learning-based method may sometimes benefit from simpler placement behavior. Even so, Graph Scheduling remains more balanced under disturbance, particularly in the bursty condition, where it substantially reduces communication overhead and execution cost relative to the MLP baseline.
A useful way to interpret these results is to distinguish between static difficulty and dynamic sensitivity. Stable settings mainly test whether a scheduler can exploit structural information under fixed conditions. Bursty settings additionally test whether it can react to rapidly changing node contention, whereas congested settings test whether it can avoid or mitigate topology-induced communication penalties when parts of the network degrade. The proposed method performs well across all three because it is designed to respond to both sources of variation: evolving node state and heterogeneous communication structure.
The dynamic-condition experiments indicate that the proposed method is not only effective on average, but also comparatively robust when the operating environment departs from its nominal state. Its advantage is most pronounced when workload dependencies, communication locality, and runtime perturbations all influence the quality of the final schedule at the same time.
5.5. Ablation Study
We next examine the contribution of two design choices in the proposed scheduler: the communication-aware scoring term and the online resource-state update mechanism. Table 5 reports the corresponding ablation results.
Table 5.
Ablation study of the proposed method. Here, w/o denotes without. Results are reported as mean ± standard deviation over 30 independent runs. For Avg. Latency, Communication Overhead, and Execution Cost, lower values are better. The last two columns characterize assignment concentration: fewer used nodes and a higher maximum node load ratio indicate a more concentrated placement pattern.
The effect of removing communication awareness is immediate and consistent across all settings. Once the communication term is excluded from the assignment score, the scheduler becomes substantially less sensitive to the placement relationship between dependent tasks. As a result, it tends to distribute tasks across many more nodes, which can be seen from the substantially larger number of used nodes and the much smaller maximum node load ratio in Table 5. This more scattered placement leads to much higher cross-node communication cost and significantly worse latency. For example, under the medium-moderate setting, removing communication awareness increases average latency from 52.07 to 117.52 and communication overhead from 89.64 to 329.43, while also increasing the average number of used nodes from 4.37 to 9.20. Similar deterioration is observed in the medium-complex, large-moderate, and large-complex settings. These results confirm that communication-aware scoring is a central component of the proposed scheduler in edge-cloud environments where workflow dependencies and topology interact strongly.
The w/o Dynamic Resource Update variant yields numerically smaller latency and communication values than the full model. However, the additional concentration statistics indicate that this behavior is mainly explained by an unrealistically concentrated placement pattern. Without updating node states after each assignment, the scheduler repeatedly favors a very small set of initially attractive nodes. Consequently, the number of used nodes drops sharply, while the maximum node load ratio becomes extremely high. For instance, under the medium-moderate setting, the average number of used nodes decreases from 4.37 to 1.33, while the maximum node load ratio increases from 0.42 to 0.92. Similar concentration effects appear in all other settings. This concentration artificially suppresses cross-node communication and therefore produces overly optimistic latency and communication statistics under stale-state assumptions.
Taken together, the ablation results support two distinct conclusions. First, communication-aware scoring is essential for reducing topology-unfriendly placements and controlling cross-node communication overhead. Second, dynamic resource-state updates are necessary for maintaining a realistic and state-consistent online scheduling process. Ignoring state evolution may produce numerically attractive results, but these results correspond to an overly concentrated and less realistic assignment pattern rather than a faithful online scheduling regime.
5.6. Parameter Sensitivity Analysis
We further examine the sensitivity of the proposed scheduler to the main trade-off coefficients in the assignment score. According to the scoring formulation in Section 4.3, controls the execution-related term, controls the communication-related term, controls the cost-related term, and controls the structure-aware correction term. In this analysis, we fix as the reference scale and vary , , and while keeping the remaining coefficients fixed. The analysis is conducted on four representative settings, namely small-moderate, medium-moderate, large-moderate, and large-complex. The corresponding trends are shown in Figure 9, Figure 10 and Figure 11.
Figure 9.
Sensitivity of the proposed scheduler to the communication-related coefficient under four representative settings.
Figure 10.
Sensitivity of the proposed scheduler to the cost-related coefficient under four representative settings.
Figure 11.
Sensitivity of the proposed scheduler to the structure-aware correction coefficient under four representative settings.
The results show that the proposed method is most sensitive to the communication-related coefficient . When is too small, the scheduler becomes less responsive to cross-node dependency costs, which leads to noticeably larger communication overhead and worse latency. As increases from a low value to a moderate or moderately high range, both latency and communication overhead decrease consistently across the representative settings. For example, under the large-complex setting, increasing the communication-related coefficient from 0.2 to 1.1 reduces average latency from 83.41 to 74.96 and communication overhead from 357.67 to 251.68. Similar improvements are also observed under the small-moderate, medium-moderate, and large-moderate settings. This result confirms that adequately emphasizing communication-aware placement is important for graph scheduling in communication-sensitive edge-cloud environments.
The cost-related coefficient also has a visible influence on performance. In all four representative settings, increasing from a low value to a moderate-to-high range improves the overall trade-off among latency, communication overhead, and execution cost. This suggests that a reasonable cost-aware bias can help the scheduler avoid overly expensive or poorly matched placements without significantly harming execution efficiency. In particular, under the large-complex setting, increasing the cost-related coefficient from 0.1 to 0.9 reduces average latency from 84.50 to 68.06 and communication overhead from 326.82 to 221.03, while also lowering execution cost.
By contrast, the structure-aware correction coefficient has only a limited effect within the tested range. The results remain almost unchanged in the small-moderate and medium-moderate settings and vary only slightly in the large-moderate and large-complex settings. This indicates that the proposed method is relatively stable with respect to moderate changes in the correction-term weight, and that the main performance gains are driven more strongly by the explicit communication-aware and cost-aware components of the score.
Overall, the sensitivity analysis shows that the proposed scheduler is not overly fragile to coefficient selection. While the communication-related and cost-related coefficients play a more pronounced role, the method remains stable over a reasonably wide parameter range, which supports the robustness of the chosen default configuration.
6. Conclusions
This paper studied the problem of scheduling multi-agent workflows in edge-cloud environments, where effective task assignment must simultaneously account for workflow dependencies, heterogeneous resource conditions, and topology-dependent communication overhead. To address this problem, we proposed a graph-aware scheduling method that combines structural representations of workflows and resources with communication-sensitive scoring and online resource-state updates.
Experiments across different workflow complexities, system scales, and dynamic operating conditions showed that the proposed method often achieves a favorable trade-off among latency, communication overhead, and execution cost relative to representative baselines, with the clearest gains appearing in communication-sensitive and larger-scale settings. Additional ablation, significance-testing, and parameter-sensitivity results further highlighted the importance of communication-aware scoring, the role of state-consistent online scheduling, and the robustness of the chosen default configuration.
These findings suggest that graph-aware scheduling is a promising direction for supporting multi-agent workflow execution over distributed edge-cloud infrastructures. The proposed method is designed as an online constructive scheduler rather than an offline global optimizer, and it targets DAG-structured request-level workflows. Future work will consider more realistic online scheduling scenarios, stronger deployment-oriented validation, cyclic or long-running agent workflows, and more expressive yet efficient graph-based decision models.
Author Contributions
Conceptualization, S.L. and J.W.; Methodology, S.L. and C.H.; Software, S.L. and C.H.; Validation, S.L., C.H., Y.L., Z.W. and B.Z.; Formal analysis, S.L. and J.Y.; Investigation, S.L., C.H. and J.Y.; Resources, Y.L., Z.W., B.Z. and J.W.; Data curation, S.L., C.H., Y.L., Z.W. and B.Z.; Writing—original draft preparation, S.L.; Writing—review and editing, J.W., J.Y., Y.L., Z.W. and B.Z.; Visualization, S.L. and C.H.; Supervision, J.W. and J.Y. All authors have read and agreed to the published version of the manuscript.
Funding
This work was supported by the National Key R&D Program of China under Grant No. 2024YFC3307704 (May 2025–April 2028) and China Mobile Communications Group Co., Ltd. under Grant No. R25110APC01 (October 2025–September 2026).
Data Availability Statement
https://github.com/CBY-alt/graph-scheduling-edge-cloud (accessed on 14 April 2026).
Conflicts of Interest
Authors Yexuan Li, Zhao Wang, and Benhao Zhu were employed by China Mobile Communications Company Limited Research Institute, China Mobile (China), Beijing, China. The remaining authors declare that the research was conducted in the absence of any commercial or financial relationships that could be construed as a potential conflict of interest.
Abbreviations
The following abbreviations are used in this manuscript:
| DAG | Directed Acyclic Graph |
| HEFT | Heterogeneous Earliest Finish Time |
| LLM | Large Language Model |
| MLP | Multilayer Perceptron |
| SLA | Service-Level Agreement |
References
- Gort, B.; Kibalya, G.M.; Antonopoulos, A. AgentEdge: Agentic AI for Service Orchestration in the Edge-Cloud Continuum. TechRxiv 2025. [Google Scholar] [CrossRef] [Scilit]
- Li, X.; Wang, S.; Zeng, S.; Wu, Y.; Yang, Y. A survey on LLM-based multi-agent systems: Workflow, infrastructure, and challenges. Vicinagearth 2024, 1, 9. [Google Scholar] [CrossRef] [Scilit]
- Zheng, Y.; Chen, Y.; Qian, B.; Shi, X.; Shu, Y.; Chen, J. A review on edge large language models: Design, execution, and applications. ACM Comput. Surv. 2025, 57, 209. [Google Scholar] [CrossRef] [Scilit]
- Ye, J.; Chen, Y.; Simayi, A.; Liu, Y.; Lu, Z.; Wu, J. A Network Traffic Characteristics Reconstruction Method for Mitigating the Impact of Packet Loss in Edge Computing Scenarios. Future Internet 2025, 17, 208. [Google Scholar] [CrossRef] [Scilit]
- Wu, Y.; Tang, S.; Yu, C.; Yang, B.; Sun, C.; Xiao, J.; Wu, H.; Feng, J. Task scheduling in geo-distributed computing: A survey. IEEE Trans. Parallel Distrib. Syst. 2025, 36, 2073–2088. [Google Scholar] [CrossRef] [Scilit]
- Jayanetti, A.; Halgamuge, S.; Buyya, R. Reinforcement learning based workflow scheduling in cloud and edge computing environments: A taxonomy, review and future directions. arXiv 2024, arXiv:2408.02938. [Google Scholar] [CrossRef] [Scilit]
- Wang, Y.; Yang, C.; Lan, S.; Zhu, L.; Zhang, Y. End-edge-cloud collaborative computing for deep learning: A comprehensive survey. IEEE Commun. Surv. Tutor. 2024, 26, 2647–2683. [Google Scholar] [CrossRef] [Scilit]
- Patidar, P.; Crown, A.; Hsieh, K.; Xu, Y.; Chakraborty, T.; Chandra, R.; Agarwal, Y. Orchestration for domain-specific edge-cloud language models. arXiv 2025, arXiv:2507.09003. [Google Scholar]
- Adhikari, M.; Amgoth, T.; Srirama, S.N. A survey on scheduling strategies for workflows in cloud environment and emerging trends. ACM Comput. Surv. 2019, 52, 68. [Google Scholar] [CrossRef] [Scilit]
- Alkhanak, E.N.; Lee, S.P.; Rezaei, R.; Parizi, R.M. Cost optimization approaches for scientific workflow scheduling in cloud and grid computing: A review, classifications, and open issues. J. Syst. Softw. 2016, 113, 1–26. [Google Scholar] [CrossRef] [Scilit]
- Jiang, Y.; Sun, X. Efficient workflow scheduling in edge cloud-enabled space-air-ground-integrated information systems. Int. J. Semant. Web Inf. Syst. 2024, 20, 1–29. [Google Scholar] [CrossRef] [Scilit]
- NoorianTalouki, R.; Shirvani, M.H.; Motameni, H. A heuristic-based task scheduling algorithm for scientific workflows in heterogeneous cloud computing platforms. J. King Saud Univ. Comput. Inf. Sci. 2022, 34, 4902–4913. [Google Scholar] [CrossRef] [Scilit]
- Zhou, J.; Wang, T.; Cong, P.; Lu, P.; Wei, T.; Chen, M. Cost and makespan-aware workflow scheduling in hybrid clouds. J. Syst. Archit. 2019, 100, 101631. [Google Scholar] [CrossRef] [Scilit]
- Ye, J.; Yan, M.; Wu, S.; Tan, J.; Wu, J. U-SCAD: An unsupervised method of system call-driven anomaly detection for containerized edge clouds. Future Internet 2025, 17, 218. [Google Scholar] [CrossRef] [Scilit]
- Du, X. Scientific workflows in heterogeneous edge-cloud computing: A data placement strategy based on reinforcement learning. arXiv 2022, arXiv:2205.07131. [Google Scholar] [CrossRef] [Scilit]
- Hawaou, K.S.; Kamla, V.C.; Yassa, S.; Romain, O.; Mboula, J.E.N.; Bitjoka, L. Industry 4.0 and industrial workflow scheduling: A survey. J. Ind. Inf. Integr. 2024, 38, 100546. [Google Scholar]
- Topcuoglu, H.; Hariri, S.; Wu, M.Y. Performance-effective and low-complexity task scheduling for heterogeneous computing. IEEE Trans. Parallel Distrib. Syst. 2002, 13, 260–274. [Google Scholar] [CrossRef] [Scilit]
- Samadi, Y.; Zbakh, M.; Tadonki, C. E-HEFT: Enhancement heterogeneous earliest finish time algorithm for task scheduling based on load balancing in cloud computing. In 2018 International Conference on High Performance Computing & Simulation (HPCS), Orleans, France, 16–20 July 2018; IEEE: New York, NY, USA, 2018; pp. 601–609. [Google Scholar]
- Zhu, K.; Zhang, Z.; Zeadally, S.; Sun, F. Learning to optimize workflow scheduling for an edge–cloud computing environment. IEEE Trans. Cloud Comput. 2024, 12, 897–912. [Google Scholar] [CrossRef] [Scilit]
- Ghosh, R.; Komma, S.P.R.; Simmhan, Y. Adaptive energy-aware scheduling of dynamic event analytics across edge and cloud resources. In 2018 18th IEEE/ACM International Symposium on Cluster, Cloud and Grid Computing (CCGRID), Washington, DC, USA, 1–4 May 2018; IEEE: New York, NY, USA, 2018; pp. 72–82. [Google Scholar]
- Baskiyar, S.; Abdel-Kader, R. Energy aware DAG scheduling on heterogeneous systems. Clust. Comput. 2010, 13, 373–383. [Google Scholar] [CrossRef] [Scilit]
- Krishnan, N. Advancing multi-agent systems through model context protocol: Architecture, implementation, and applications. arXiv 2025, arXiv:2504.21030. [Google Scholar] [CrossRef] [Scilit]
- Liu, S.; Shen, H.; Che, S.; Ghandi, M.; Li, M. HERA: Hybrid Edge-cloud Resource Allocation for Cost-Efficient AI Agents. arXiv 2025, arXiv:2504.00434. [Google Scholar]
- Pan, J.; Wei, Y. A deep reinforcement learning-based scheduling framework for real-time workflows in the cloud environment. Expert Syst. Appl. 2024, 255, 124845. [Google Scholar] [CrossRef] [Scilit]
- Kiamari, M.; Krishnamachari, B. GCNScheduler: Scheduling distributed computing applications using graph convolutional networks. In Proceedings of the 1st International Workshop on Graph Neural Networking, Rome, Italy, 9 December 2022; Association for Computing Machinery: New York, NY, USA, 2022; pp. 13–17. [Google Scholar]
- Sharma, A.K.; Kunkel, J. Grapheon RL: A Graph Neural Network and Reinforcement Learning Framework for Constraint and Data-Aware Workflow Mapping and Scheduling in Heterogeneous HPC Systems. In 2025 IEEE 49th Annual Computers, Software, and Applications Conference (COMPSAC), Toronto, ON, Canada, 8–11 July 2025; IEEE: New York, NY, USA, 2025; pp. 489–494. [Google Scholar]
- Chowdhury, F.; Di Natale, F.; Moody, A.; Mohror, K.; Yu, W. DFMan: A graph-based optimization of dataflow scheduling on high-performance computing systems. In 2022 IEEE International Parallel and Distributed Processing Symposium (IPDPS), Lyon, France, 30 May–3 June 2022; IEEE: New York, NY, USA, 2022; pp. 368–378. [Google Scholar]
- Hu, L.; Wu, X.; Che, X. HICA: A Hybrid Scientific Workflow Scheduling Algorithm for Symmetric Homogeneous Resource Cloud Environments. Symmetry 2025, 17, 280. [Google Scholar] [CrossRef] [Scilit]
- Al-Maytami, B.A.; Fan, P.; Hussain, A.; Baker, T.; Liatsis, P. A task scheduling algorithm with improved makespan based on prediction of tasks computation time algorithm for cloud computing. IEEE Access 2019, 7, 160916–160926. [Google Scholar] [CrossRef] [Scilit]
- Guo, T.; Chen, X.; Wang, Y.; Chang, R.; Pei, S.; Chawla, N.; Wiest, O.; Zhang, X. Large Language Model based Multi-Agents: A Survey of Progress and Challenges. In Proceedings of the 33rd International Joint Conference on Artificial Intelligence (IJCAI 2024), Jeju, Republic of Korea, 3–9 August 2024; Association for Computing Machinery: New York, NY, USA, 2024. [Google Scholar]
- He, J.; Treude, C.; Lo, D. Llm-based multi-agent systems for software engineering: Literature review, vision, and the road ahead. ACM Trans. Softw. Eng. Methodol. 2025, 34, 1–30. [Google Scholar] [CrossRef] [Scilit]
- Zeeshan, T.; Kumar, A.; Pirttikangas, S.; Tarkoma, S. Large language model based multi-agent system augmented complex event processing pipeline for internet of multimedia things. arXiv 2025, arXiv:2501.00906. [Google Scholar] [CrossRef] [Scilit]
- Jayanetti, J.A.A.M. Workflow Scheduling in Cloud and Edge Computing Environments with Deep Reinforcement Learning. Ph.D. Thesis, University of Melbourne, Parkville, VIC, Australia, 2023. [Google Scholar]
- Masdari, M.; ValiKardan, S.; Shahi, Z.; Azar, S.I. Towards workflow scheduling in cloud computing: A comprehensive analysis. J. Netw. Comput. Appl. 2016, 66, 64–82. [Google Scholar] [CrossRef] [Scilit]
- Hosseini Shirvani, M. A survey study on task scheduling schemes for workflow executions in cloud computing environment: Classification and challenges. J. Supercomput. 2024, 80, 9384–9437. [Google Scholar] [CrossRef] [Scilit]
- Chen, N.; Zhang, S.; Wu, J.; Qian, Z.; Lu, S. Learning scheduling bursty requests in Mobile Edge Computing using DeepLoad. Comput. Netw. 2021, 184, 107655. [Google Scholar] [CrossRef] [Scilit]
- Fiad, A.; Maaza, Z.M.; Bendoukha, H. Improved version of round robin scheduling algorithm based on analytic model. Int. J. Netw. Distrib. Comput. 2020, 8, 195–202. [Google Scholar] [CrossRef] [Scilit]
- Maheswaran, M.; Ali, S.; Siegel, H.J.; Hensgen, D.; Freund, R.F. Dynamic mapping of a class of independent tasks onto heterogeneous computing systems. J. Parallel Distrib. Comput. 1999, 59, 107–131. [Google Scholar] [CrossRef] [Scilit]
- Hu, Y.; You, H.; Wang, Z.; Wang, Z.; Zhou, E.; Gao, Y. Graph-mlp: Node classification without message passing in graph. arXiv 2021, arXiv:2106.04051. [Google Scholar] [CrossRef] [Scilit]
- Chakravarthi, K.K.; Shyamala, L.; Vaidehi, V. TOPSIS inspired cost-efficient concurrent workflow scheduling algorithm in cloud. J. King Saud Univ. Comput. Inf. Sci. 2022, 34, 2359–2369. [Google Scholar] [CrossRef] [Scilit]
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content. |
© 2026 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license.










