Effective Cloud–Edge Workflow Scheduling via Decoupled Offline Learning and Unified Sequence Modeling

Abstract

Efficient workflow scheduling in cloud–edge environments is severely bottlenecked by long-horizon dependencies and myopic resource fragmentation. This paper proposes the Decoupled Offline Sequence-based (DOS) scheduling framework to address these challenges. By decoupling expert policy learning from runtime deployment, DOS utilizes a multi-dimensional priority-aware linearization strategy to deterministically transform DAG-structured workflows into dependency-consistent sequences. Leveraging offline expert trajectories, we train UDC, a Gated CNN achieving unified sequence modeling via innovative triplet-to-unary encoding, equipped with explicit action masking to distill long-horizon spatio-temporal packing patterns. This mechanism enables rapid feed-forward inference without costly online environment interactions or policy updates. Extensive evaluations on real-world Alibaba cluster workloads demonstrate that DOS not only consistently minimizes average makespan compared to classical heuristics, but also drastically reduces resource-blocked steps under extreme concurrency versus online Actor–Critic experts. Crucially, compared to the Decision Transformer (DT) baseline, the UDC model achieves strictly scale-invariant and significantly lower inference latency, highlighting its robust scalability and practicality for large-scale continuum systems.

1. Introduction

With the rapid expansion of latency-sensitive and computation-intensive services, such as autonomous driving perception pipelines, real-time medical diagnostics, and industrial digital twins, cloud–edge computing has emerged as a foundational architecture for modern intelligent systems [1]. In cloud–edge environments, computational tasks are distributed across heterogeneous edge nodes and centralized cloud servers, requiring scheduling decisions to be made under dynamic network conditions, fluctuating resource availability, and diverse workload characteristics.

Many cloud–edge applications can be naturally modeled as workflows, in which application logic is decomposed into interdependent tasks represented as directed acyclic graphs (DAGs), where nodes correspond to individual computational tasks, and directed edges indicate task dependencies that must be respected during execution. We focus on such DAG-based workflows, which are widely adopted in practice and provide a well-defined abstraction for scheduling decisions [2,3].

Traditional workflow scheduling methods, including heuristic rules (e.g., FCFS [4], HEFT [5]) and meta-heuristic optimization algorithms (e.g., PSO [6], GA [7]), remain popular due to their simplicity or global optimization capabilcessed ities. However, these methods are often constrained when deployed in dynamic cloud–edge environments: heuristics rely on fixed decision rules and cannot adapt to rapidly changing resource conditions, while meta-heuristic methods require iterative computation, which may be challenging under limited interaction budgets or resource-constrained edge nodes.

Learning-based scheduling approaches, particularly reinforcement learning (RL), provide a promising alternative. Online Actor–Critic (AC) methods [2,8] model scheduling as a sequential decision-making problem. Extensions such as KaiS [8] and MCDS [9] integrate Quality of Service (QoS) prediction, graph neural networks (GNNs), and multi-agent coordination. While effective in simulated environments, their direct deployment in real-world edge settings presents significant challenges. The primary risk stems from the online exploration process, in production environments, trial-and-error behaviors inevitably cause unpredictable scheduling fluctuations and potential QoS violations. Furthermore, reliance on complex state representations introduces substantial runtime computational overhead, limiting throughput on resource-constrained devices.

Offline RL offers a complementary approach by learning from historical expert trajectories without requiring active environment interaction. While traditional offline methods primarily focus on value function estimation, which often struggles with out-of-distribution action evaluation and complex long-horizon credit assignment [10,11], recent advancements have reformulated scheduling as an autoregressive sequence prediction task. This paradigm shift translates offline policy learning into a more stable supervised learning problem. Models such as Decision Transformer (DT) [12] capture long-horizon strategies directly based on past states, actions, and return-to-go (RTG) values. However, these models face a critical limitation: when handling large-scale workflows, the computational complexity of the standard self-attention mechanism scales quadratically with the sequence length. This quadratic scaling leads to significantly increased and unstable inference latency, restricting practical deployment on resource-constrained edge nodes.

To overcome the quadratic complexity of self-attention, linear-time sequence architectures, such as Decision Convformer (DC) [13] and Unified Decision Convolution (UDC) [14], have emerged as efficient alternatives capable of $\mathcal{O}\left(N\right)$ feed-forward inference. Leveraging this advancement, this paper proposes a decoupled workflow scheduling framework that strictly separates policy learning from runtime execution. Our approach confines the exploration-heavy AC training entirely to an offline simulation phase for expert trajectory generation, effectively mitigating the risk of online trial-and-error. Subsequently, the lightweight UDC model is trained on these expert trajectories to serve as the runtime scheduling engine. To bridge DAG-structured workflows and sequential modeling, we introduce a priority-aware topological linearization that preserves dependency constraints.

Empirical evaluations on real-world cluster traces demonstrate that the proposed framework achieves lower average workflow makespans compared to standard heuristic baselines. Furthermore, comparisons with offline sequence and online RL baselines validate that the decoupled approach effectively limits inference latency growth under large-scale workloads, offering a practical trade-off between per-workflow scheduling quality and system-level execution efficiency.

In summary, this work seeks to improve the deployment practicality and stability of learning-based schedulers through the following key contributions:

• We propose a decoupled offline sequence-based scheduling approach (DOS) that confines AC exploration to an offline phase, mitigating runtime trial-and-error risks and improving deployment safety.
• We leverage a unified sequence-based decision model as a runtime scheduling engine, aiming to achieve stable, linear-time feed-forward inference without the need for online policy optimization.
• We design a priority-aware workflow linearization strategy that transforms DAGs into ordered sequences, preserving dependency information for sequence models without introducing additional computational overhead.

The remainder of this paper is organized as follows. Section 2 reviews related work. Section 3 introduces the cloud–edge system model and formulates the scheduling problem. Section 4 details the proposed decoupled scheduling framework. Section 5 presents the experimental results, followed by discussions and limitations. Finally, Section 6 concludes the paper.

2. Related Work

Workflow scheduling in cloud–edge environments has evolved from traditional heuristic rules to data-driven learning paradigms. While traditional heuristics (e.g., HEFT [5]) offer low computational overhead, their limited adaptability in dynamic environments has driven the adoption of learning-based approaches. Current learning-based scheduling can be broadly categorized into online RL methods and offline sequence modeling approaches.

Online RL methods optimize scheduling policies through continuous interaction with the environment. Early studies adopted foundational value-based and policy-based algorithms, such as Deep Q-Networks (DQNs) [15] and AC frameworks [2], to achieve adaptive task-resource mapping under dynamic network conditions and heterogeneous node capabilities. Subsequent works, such as MCDS [9] and KaiS [8], integrate QoS prediction, multi-agent coordination, GNNs, and priority-aware scheduling to handle containerized systems and complex cloud–edge platforms. Beyond these examples, online RL approaches have explored multi-objective optimization, jointly considering metrics such as makespan, energy consumption, and resource utilization, as well as value function shaping or model-based improvements to accelerate learning [16,17,18]. However, these enhancements introduce additional runtime computations, coordination overhead, and memory requirements. Furthermore, online RL inherently requires environment exploration. In real-world edge settings, this trial-and-error process may result in unpredictable scheduling behaviors, potential service violations, and increased operational risk [19]. While online RL can achieve high-quality scheduling decisions in controlled or simulated environments, its runtime cost, uncertainty, and coordination demands limit its direct deployment in latency-sensitive or resource-constrained edge settings, motivating the development of offline or decoupled frameworks.

Offline and imitation-based scheduling methods learn decision policies from pre-collected or simulated expert trajectories, avoiding costly online exploration and improving deployment stability [20]. For example, GOODRL [21] integrates imitation learning with graph attention-enhanced AC networks to capture workflow dependencies in heterogeneous cloud environments. While such methods are highly effective at modeling complex topologies, graph-based and attention-heavy architectures inherently possess high computational complexity. Consequently, these architectures can introduce significant computational and memory overhead during runtime execution, particularly in latency-sensitive or resource-constrained edge systems [22].

Recent works have reformulated workflow scheduling as an autoregressive sequence modeling problem. By serializing DAG-structured workflows into token sequences, scheduling policies can be learned via offline token prediction. Originally, DT [12] formulated RL as a sequence generation task, predicting actions based on past states and RTG values. Building on this foundation, sequence modeling has been applied to scheduling problems to capture the long-horizon task dependencies inherent in complex workflows [23]. However, these architectures face a critical efficiency bottleneck. The standard self-attention mechanism scales quadratically ($\mathcal{O}\left(N^2\right)$) with the sequence length N. In cloud–edge environments, where workflows often comprise thousands of interdependent tasks, this quadratic scaling leads to prohibitive inference latency, severely restricting practical deployment on edge nodes.

To address this scalability issue in large-scale workflow scheduling, convolution-based sequence models, such as DC [13] and UDC [14], have been proposed. By replacing self-attention with causal convolutions, these architectures achieve linear-time ($\mathcal{O}\left(N\right)$) feed-forward inference. This ensures stable decision-making latency regardless of the workflow size, making them highly practical for deploying sequence-based scheduling policies in resource-constrained systems. Crucially, they retain the ability to capture the long-horizon trajectory dependencies learned from experts, effectively balancing scheduling quality and runtime efficiency.

Despite these advances, existing learning-based schedulers generally face a critical dilemma. On one hand, online methods introduce exploration risks and scalability bottlenecks, since complex graph processing and expanding action spaces struggle to scale to thousands of tasks. On the other hand, current offline sequence models suffer from the quadratic inference latency of attention mechanisms. To clarify the research boundaries and the specific gaps addressed by our framework,

Table 1. Systematic comparison of representative workflow scheduling paradigms.

Method	Learning Paradigm	Core Architecture	Inference Latency	Online Risk	Adaptability	Scalability
HEFT [4]	Heuristic	Priority-based	$\mathcal{O}(N+E)$	No	Low	High
Standard AC [2]	Online RL	MLP/FFN	$\mathcal{O}\left(N\right)$	Yes	Moderate	Low
KaiS [8]	Online RL	GNN + AC	$\mathcal{O}(N^2+N·E)$	Yes	High	Low
GOODRL [21]	Offline-Online RL	Graph Attention	$\mathcal{O}(N^2+N·E)$	Partial	High	Moderate
DT [12]	Offline Sequence	Self-Attention	$\mathcal{O}\left(N^2\right)$	No	High	Moderate
DOS (Ours)	Decoupled Sequence	Convolution	$\mathcal{O}\left(N\right)$	No	High	High

presents a systematic comparison of representative scheduling paradigms, including both traditional heuristics and modern learning models. In contrast to tightly coupled models, our framework decouples policy learning from runtime execution by confining AC training to an offline phase for expert trajectory generation, and using the lightweight UDC model for online inference. This decoupled design eliminates the risks associated with online exploration and avoids the quadratic latency bottleneck of traditional architectures. By achieving linear-time inference, DOS effectively balances deployment practicality, high adaptability, and extreme scalability for large-scale cloud–edge workflows.

3. System Model and Problem Formulation

This study focuses on a cloud–edge workflow execution scenario in which task scheduling decisions must be made under dynamic system states and long-term performance objectives. The goal is to determine efficient task-to-resource mappings that respect workflow dependencies while satisfying latency, resource, and deployment constraints inherent in cloud–edge environments.

3.1. Cloud–Edge Infrastructure and Workflow Modeling

The proposed architecture assumes a collaborative edge–cloud computing system for dynamic workflow scheduling, as illustrated in Figure 1. Let $\mathcal{E}=\{1,2,\dots ,E\}$ denote the set of edge clusters. Each edge cluster $e\in \mathcal{E}$ consists of heterogeneous edge nodes ${\mathcal{N}}_e=\{n_1,n_2,\dots ,n_b\}$. A centralized cloud center $\mathcal{C}$ provides abundant resources and is connected to each edge cluster via a wide area network (WAN).

We denote by ${\tau }_e$ the intra-cluster transmission delay within edge cluster e, and by ${\tau }_{e,c}$ the transmission delay to the cloud center. To support workflow execution, services are deployed as containerized types. Each node n hosts a subset of service types ${\mathcal{W}}_n\subseteq \mathcal{W}$, constrained by its maximum CPU capacity $C_{max}^n$ and memory capacity $M_{max}^n$. A task $t_i$ requiring service type $w_i$, CPU $c_i$, and memory $m_i$ can be executed on node n at decision step t only if the multi-service constraints are strictly met $w_i\in {\mathcal{W}}_n$ and:

$$C_{used}^n\left(t\right)+c_i\le C_{max}^n,M_{used}^n\left(t\right)+m_i\le M_{max}^n$$

(1)

the cloud center $\mathcal{C}$ is assumed to host all service types with virtually unlimited capacities, serving as a fallback execution site.

A workflow is modeled as a DAG $\mathcal{G}=(\mathcal{T},{\mathcal{E}}_{dag})$, where $\mathcal{T}$ represents the set of tasks, and ${\mathcal{E}}_{dag}$ represents the precedence constraints. To concretely handle DAG dependencies and network latency, a task $t_j$ cannot commence until all its predecessors $t_i\in pred\left(t_j\right)$ have completed and transferred their outputs. The readiness of $t_j$ on target node n is governed by the Earliest Start Time (EST) constraint:

$$EST(t_j,n)=\underset{t_i\in pred\left(t_j\right)}{max}\left\{EFT\left(t_i\right)+{\tau }_{loc\left(t_i\right),n}\right\}$$

(2)

where $EFT\left(t_i\right)$ denotes the Earliest Finish Time of the predecessor $t_i$. The term ${\tau }_{loc\left(t_i\right),n}$ represents the corresponding communication delay, which is determined by the deployment sites of $t_i$ and n; specifically, it takes the value of ${\tau }_e$ for intra-cluster transfers, ${\tau }_{e,c}$ for cluster-to-cloud communications, or zero when tasks are locally assigned to the same node.

3.2. MDP Formulation and Expert Trajectory Generation

Based on the infrastructure model, the scheduling process is cast as a Markov Decision Process (MDP) defined by $\langle \mathcal{S},\mathcal{A},\mathcal{P},\mathcal{R},\gamma \rangle$, where $\gamma \in [0,1)$ acts as the discount factor balancing immediate and future returns.

State Space: At each decision step t, the system context is encoded into a continuous state vector $s_t\in \mathcal{S}$. To comprehensively capture the cloud–edge continuum, this vector hierarchically concatenates three feature subsets: (1) task-level features, encompassing normalized resource requirements, estimated execution duration, topological dependency count, and the requested service container type; (2) host-level dynamic status, tracking real-time CPU and memory utilization, task queue lengths, and specific container availability across nodes; and (3) cluster-level macro statistics, including aggregated workflow completion rates and the normalized simulation clock.

Action Space and Transitions: The action $a_t\in \mathcal{A}$ corresponds to selecting a target execution node for the currently ready task, spanning both local edge hosts and cloud replicas. To ensure strict adherence to the multi-service and resource constraints defined in Equation (1), the available action space at each step t is dynamically restricted to a feasible subset ${\mathcal{A}}_t\subseteq \mathcal{M}$. A candidate node belongs to ${\mathcal{A}}_t$ only if it satisfies both service compatibility and resource availability requirements, which acts as an explicit resource masking mechanism. Upon executing a valid action $a_t\in {\mathcal{A}}_t$, the environment transitions to $s_{t+1}$ following the dynamics $\mathcal{P}$. The scheduling episode reaches its terminal state done exclusively when all workflows within the workload are completely resolved or when a maximum simulation step limit is exhausted.

Reward Function: The reward $\mathcal{R}$ evaluates the quality of scheduling decisions via a composite structure that merges dense task-level signals with sparse long-horizon objectives. For each successfully scheduled task, a dense reward $r_t^w=1-(d_t+c_t)/\kappa +\varphi$ is issued, where $d_t$ and $c_t$ denote the computation and communication delays, $\kappa$ is a normalization constant, and $\varphi$ encapsulates heuristic deployment preferences (e.g., favoring local execution). Infeasible actions incur a fixed penalty. Furthermore, to capture long-term efficiency, a terminal reward $r^w=\lambda ·f\left(T_w\right)$ is superimposed when a task completes an entire workflow, where $T_w$ is the makespan and $f(·)$ is a monotonically decreasing function. This total reward $r_t$ provides immediate execution feedback while securely embedding global makespan minimization objectives.

Return-to-Go and Trajectory Generation: To bridge dynamic workflow scheduling with offline sequence modeling, we utilize the RTG representation derived from the DT to encode expert objectives. For each scheduling trajectory, the RTG at step t is calculated as ${\widehat{R}}_t={\sum }_{t^{\prime }=t}^T{r}_{t^{\prime }}$. This formulation effectively propagates terminal workflow-level rewards back to early scheduling decisions. During dataset construction, rather than recording a single monolithic log, the trajectory collector operates at the cluster level. It generates parallel sequences $\tau =(s_1,a_1,r_1,\dots ,s_N,a_N,r_N)$ for each edge master node. A rigorous filtering mechanism is then applied to exclude trajectories containing invalid termination reasons. As an offline conditioning signal, ${\widehat{R}}_t$ guides the UDC model to reproduce expert-like distributions during inference, seamlessly decoupling the feed-forward execution from the complex online reward optimization process.

4. Methodology

4.1. Framework Overview

We propose a decoupled offline scheduling framework for cloud–edge workflows, as illustrated in Figure 2. The framework explicitly decouples policy learning from runtime execution by separating an exploration-intensive learning stage from an efficient, inference-only deployment stage.

During the learning stage, a distributed AC scheduler is trained through interaction with a simulated cloud–edge environment. The distributed AC framework employs independent actors and a shared critic for scalable task-level scheduling. The objective of this stage is not to obtain a deployable online scheduler, but to generate high-quality expert trajectories that capture long-horizon scheduling behaviors induced by workflow dependencies, heterogeneous resources, and communication delays.

After training converges, the learned AC policy is frozen and used solely as an expert to generate scheduling trajectories. These trajectories are then converted into sequential decision representations and used to train a UDC model in an offline, supervised manner. The UDC model learns to reproduce expert scheduling behaviors by conditioning on historical decision contexts and return-to-go signals, rather than by directly optimizing a reinforcement learning objective.

During deployment, the trained UDC model acts as the online scheduler. Scheduling decisions are generated through feed-forward inference without requiring environment interaction, policy updates, or value estimation.

4.2. Priority-Aware Workflow Linearization

A central challenge in applying sequence-based decision models to workflow scheduling lies in reconciling the directed acyclic graph (DAG) structure of workflows with the strictly ordered inputs required by sequential models. To address this challenge, we introduce a priority-aware workflow linearization strategy that deterministically maps a DAG-structured workflow into a dependency-consistent task sequence.

Each workflow is modeled as a directed acyclic graph $\mathcal{G}=(\mathcal{T},\mathcal{E})$, where $\mathcal{T}=\{t_1,\dots ,t_N\}$ denotes the set of tasks and $\mathcal{E}\subseteq \mathcal{T}\times \mathcal{T}$ represents precedence constraints. A task may be scheduled only after all its predecessors have completed.

At decision step k, the ready task set is defined as

$${\mathcal{R}}_k=\{t\in \mathcal{T}\setminus {\mathcal{T}}_{1:k-1}\mid \mathrm{Pred}\left(t\right)\subseteq {\mathcal{T}}_{1:k-1}\},$$

(3)

where ${\mathcal{T}}_{1:k-1}$ denotes the set of tasks already scheduled. This definition ensures that all candidate tasks satisfy DAG constraints.

When multiple tasks are ready, an ordering is determined using a priority score derived from workflow structure. For each task $t\in {\mathcal{R}}_k$, we compute its remaining critical path length

$$\pi \left(t\right)=\underset{p\in \mathcal{P}\left(t\right)}{max}\sum _{t_j\in p}w\left(t_j\right),$$

(4)

where $\mathcal{P}\left(t\right)$ denotes all directed paths from t to the workflow sink, and $w\left(t_j\right)$ is the estimated computation cost of task $t_j$.

The selected task at step k is

$$t_k=arg\underset{t\in {\mathcal{R}}_k}{max}\pi \left(t\right),$$

(5)

prioritizing tasks on longer critical paths. Importantly, this linearization serves solely as a structural transformation that produces a valid decision sequence. It does not impose additional optimization objectives or heuristic scheduling policies.

The resulting workflow is unfolded into a sequence of scheduling decisions

$$(t_1,a_1),(t_2,a_2),\dots ,(t_N,a_N),$$

(6)

where $a_k$ denotes the task-to-host assignment for task $t_k$. This unified sequential representation is shared by both the Actor–Critic trajectory generation stage and the UDC model training.

4.3. Expert Trajectory Generation via Actor–Critic

To construct a high-quality offline dataset, we pre-train an expert policy using a multi-agent Actor–Critic architecture tailored for the cloud–edge continuum.

4.3.1. Network Architecture and Optimization

Both the actor and critic networks are parameterized by Multi-Layer Perceptrons (MLPs) operating strictly within a centralized training with decentralized execution (CTDE) paradigm. This architecture ensures system-wide coordination across the cloud–edge continuum through two primary mechanisms. (i) Centralized state-value evaluation (Critic): During the offline trajectory generation phase, the global critic aggregates the local state vectors ($s_t^i$) from all individual edge clusters to construct a comprehensive global system view ($s_t$). This enables the network to accurately evaluate the joint state-value function $V_{\varphi }\left(s_t\right)$. (ii) Decentralized execution and feasibility masking (Actors): Local actors employ an MLP architecture to directly map their respective local cluster states ($s_t^i$) to discrete scheduling logits. To strictly enforce physical constraints, these logits undergo an explicit masking mechanism that filters out invalid or saturated edge nodes. The masked logits are then passed through a softmax layer to output valid action probabilities.

After executing the joint action $a_t$ and observing the system reward $r_t$ and the next global state $s_{t+1}$, the centralized critic computes the temporal difference advantage:

$$A_t=r_t+\gamma V_{\varphi }\left(s_{t+1}\right)-V_{\varphi }\left(s_t\right)$$

(7)

which is subsequently used to guide the distributed policy gradient updates of the local actors.

4.3.2. Expert Trajectory Generation and Sequential Encoding

The offline trajectory corpus serves as the foundational decision manifold for the sequence model. We utilize an iterative refinement process to optimize the AC expert, ensuring the collected data reflects high-fidelity task-to-node mapping strategies. Crucially, rather than filtering out unsuccessful scheduling attempts, our pipeline explicitly retains failed transitions caused by resource exhaustion or service unavailability. By labeling these boundary cases, the dataset encapsulates the hard constraints of the physical environment. This allows the downstream model to implicitly recognize “forbidden” state–action pairs, thereby significantly reducing invalid scheduling decisions and systemic congestion in high-concurrency scenarios.

To bridge the gap between episodic execution and autoregressive modeling, raw expert traces are encoded into standardized sequential segments. We employ a sliding-window strategy to partition long-horizon trajectories into fixed-length sequences with a context window L. Centrally, each transition is conditioned on the $RT{G}_t$ to reflect the long-term optimization objective, such as makespan minimization. This sequential encoding transforms the global dependencies of the workflow DAG into a format amenable to unified sequence modeling. By distilling complete execution patterns from both successful and corrective trajectories, the DOS framework effectively captures the spatio-temporal dynamics required for efficient cloud–edge scheduling.

4.4. Unified Decision Convolution for Sequence-Based Scheduling

With the offline expert dataset constructed, the online scheduling of cloud–edge workflows is formulated as an autoregressive sequence generation task. To map dynamic workflow states to node assignments under strict latency constraints, we employ the UDC architecture [14] as our foundational sequence model.

4.4.1. Workflow Context Construction and Sequence Processing

Following the priority-aware DAG linearization, our framework structures the expert demonstrations into sequences of discrete scheduling steps. For each decision step t, we define the context using three components: the target return-to-go ${\widehat{R}}_t$, the workflow state $s_t$, as formulated in Section 3.2 to encapsulate task-level features and dynamic host status, and the preceding scheduling decision $a_{t-1}$.

Rather than processing these components independently, the UDC architecture fuses ${\widehat{R}}_t$, $s_t$, and $a_{t-1}$ into a single contextual token via a triplet-to-unary encoding mechanism. This inherent unified encoding efficiently consolidates the scheduling history of previously allocated tasks, bounding the memory footprint while retaining the extensive DAG context required for edge environments. Subsequently, the sequence of unified tokens, maintained over a fixed context window of length K, is processed by the model’s stacked causal convolutions. This mechanism prevents information leakage, ensuring that the prediction of the current scheduling action ${\widehat{a}}_t$ relies solely on the packed context of already-scheduled tasks. Operating with strictly $O\left(K\right)$ time complexity with respect to the context length, this structural design directly addresses the latency bottlenecks of dynamic workflow scheduling.

4.4.2. Policy Learning and Masked Inference

The model is trained via return-conditioned supervised learning, optimized using a Cross-Entropy loss between the predicted node assignments and the expert’s actual decisions. During online deployment, edge nodes exhibit heterogeneous service availabilities and hard resource limits. To bridge the gap between theoretical sequence modeling and physical execution feasibility, we introduce a dynamic action masking mechanism. At each decision step t, the system identifies a subset of feasible candidate nodes based on the real-time resource capacities and service dependencies defined in Section 3.1. The sequence model outputs a raw logit vector over the entire discrete action space. The mask then explicitly filters this vector by assigning a large negative penalty (e.g., $-\infty$) to the logits corresponding to invalid nodes. The final scheduling decision is determined by applying an $argmax$ operation over the masked logits. This strict mathematical constraint ensures absolute validity in task-to-node assignments without requiring online trial-and-error.

5. Results and Discussion

This section evaluates the proposed scheduling framework in a discrete-event cloud–edge simulation environment.

5.1. Experimental Setup and Baselines

Simulation Environment and Workloads: The simulated cloud–edge environment consists of a centralized over-provisioned cloud and three geographically distributed edge clusters. To drive the simulation with realistic system contention, workflow requests are derived from the Alibaba Cluster Trace v2018 [24]. Compared to synthetic workflows [3,25], this production dataset exhibits highly skewed resource requirements and complex dependency patterns. We extract dynamic DAG-structured workflows directly from the batch_task.csv table, where task precedence constraints are intrinsically captured to construct the workflow topologies. Based on trace profiling, tasks are categorized into six containerized service specifications.

Evaluation Scales and Distributed Deployment: To comprehensively assess system-level scalability, we evaluate the proposed framework across five distinct workload sizes: 500, 1000, 5000, 10,000, and 20,000 workflow requests. Processing up to 20,000 workflows involves millions of simulated task-to-node allocation decisions, which is designed to test the computational overhead and stability of the scheduling agents under massive system loads. The online sequence-based schedulers are deployed on three geographically distributed edge master nodes rather than a centralized cloud. Deploying schedulers at the network edge localizes the decision-making process, avoiding the transmission latency and bandwidth overhead associated with sending continuous real-time state updates and scheduling actions to the cloud [26,27].

Baseline Algorithms: We compare the proposed DOS framework against five distinct baselines:

• Heuristic Algorithms (HEFT, EST, PEFT): HEFT [28] is a classical DAG scheduling heuristic based on the earliest finish time. EST [5] is a greedy strategy minimizing the estimated start time. PEFT [5] considers both task ranking and finish time.
• Online RL Expert (AC): A continuous-state Actor–Critic agent trained interactively within the online environment, representing the theoretical performance upper bound for learning-based dynamic scheduling.
• Decision Transformer (DT): A standard offline sequence decision model relying on the conventional self-attention mechanism, introduced to explicitly benchmark the architectural and latency advantages of the UDC model employed in DOS.

All baseline methods are rigorously evaluated under identical workflow arrivals, resource constraints, and service availabilities on a workstation equipped with an NVIDIA RTX A6000 GPU. To ensure fair comparisons, the UDC and DT sequence models share equivalent context lengths, parameter scales, and training horizons. For strict reproducibility, the detailed hardware specifications, network latencies, and containerized service footprints are consolidated in Appendix A, detailed architectural and hyperparameter configurations are provided in Appendix B for the AC expert, and Appendix C for the sequence models. All neural models are evaluated across three random seeds, given negligible variance, and the reported metrics represent their average performance. All learning-based models and heuristic baselines were implemented in Python 3.8 using the same simulation framework, with no model-specific hardware acceleration libraries (e.g., TensorRT) enabled during inference.

5.2. Scheduling Performance and Scalability

To evaluate the scheduling efficacy and scalability of the DOS framework, we extract three critical metrics across varying workload sizes: Average Workflow Makespan, Global End Time, and Invalid Scheduling Steps. The comparative results are presented in Figure 3.

As workload sizes scale from 500 to 20,000, traditional heuristic methods exhibit rapid performance degradation. While heuristics yield acceptable queuing delays at lower concurrency, their average workflow makespans surge disproportionately as system contention intensifies. This deteriorating trend highlights the inherent limitation of rule-based greedy assignments, which lack a holistic view of DAG dependencies and frequently saturate bottleneck edge nodes. In contrast, the offline sequence models, namely DOS and DT, demonstrate highly resilient scalability. By capturing long-term task dependencies, they maintain a graceful degradation curve across all scales, ultimately reducing the average makespan by approximately 86% and 78% compared to HEFT and EST at the 20,000 scale.

Furthermore, cross-scale evaluations reveal a critical limitation of the online AC expert: while it achieves comparable efficiency at smaller scales, it suffers from severe systemic congestion as the workload intensifies. Governed by a Markovian policy, the AC agent makes myopic dispatch decisions based solely on the immediate state snapshot. Under extreme concurrency, this localized greediness leads to severe resource fragmentation, causing a drastic multiplication of resource-blocked steps, defined as scheduling cycles where ready tasks are stalled due to absolute resource depletion across all permitted nodes. This fragmentation disproportionately extends its global system end time. The offline sequence models, specifically the UDC model driving our DOS framework and the DT baseline, overcome this deadlock through autoregressive sequence modeling. By conditioning on a historical sequence window of past assignments and RTG signals, they distill the expert’s effective long-horizon packing patterns while discarding its localized myopic noise. Operating under the identical explicit action masking constraint as the AC expert, this sequence-aware approach successfully avoids premature resource saturation. By reducing resource-blocked steps by nearly 88% compared to the AC expert at the maximum evaluated scale, DOS achieves an over 74% improvement in the global system end time, demonstrating exceptional scalability in massive cloud–edge workflows.

5.3. Computational Overhead Analysis

To evaluate edge deployment feasibility, we analyze the computational overhead of all scheduling methods as shown in

Table 2. Computational overhead and system throughput comparison across all evaluation scales. Arrows ↓ indicate that smaller values are better, Arrows ↑ indicate that bigger values are better, and bold formatting highlights the best results for each metric.

Workflows Scale	Metric	HEFT	EST	PEFT	AC	DT	DOS (Ours)
500	Decision latency (ms) ↓	0.17	13.99	14.70	1.47	13.26	3.74
	Workflow throughput/s ↑	0.091	0.101	0.102	0.107	0.107	0.108
1000	Decision latency (ms) ↓	0.80	35.10	37.45	1.45	13.60	3.34
	Workflow throughput/s ↑	0.048	0.053	0.053	0.055	0.055	0.055
5000	Decision latency (ms) ↓	3.94	199.32	212.29	1.61	11.65	3.67
	Workflow throughput/s ↑	0.194	0.212	0.206	0.272	0.273	0.274
10,000	Decision latency (ms) ↓	8.05	413.37	433.11	1.70	13.64	3.75
	Workflow throughput/s ↑	0.226	0.310	0.317	0.097	0.446	0.447
20,000	Decision latency (ms) ↓	15.84	838.87	848.50	1.82	12.12	3.82
	Workflow throughput/s ↑	0.220	0.311	0.225	0.098	0.383	0.383

. Heuristic baselines are evaluated on a 12-core Intel Xeon CPU, while neural policies (AC, DT, DOS) utilize an NVIDIA RTX A6000 GPU. We report Decision latency as the pure wall-clock time required to execute decision step, which strictly excludes any overhead from environment interactions. Furthermore, Workflow throughput is reported as the number of completed workflows per simulated second.

Results show that while heuristics compute decisions rapidly at smaller scales, their calculation overhead explodes under high concurrency. At the scale of 20,000 workflows, HEFT and EST become computationally intractable for real-time environments, as rule-based methods must iteratively traverse massive task queues to estimate finish times. Meanwhile, although the online AC method maintains low decision latency, its global workflow throughput drops drastically due to severe system-level congestion.

In contrast, offline sequence models maintain optimal system throughput. However, the DT model, constrained by the $O\left(K^2\right)$ complexity of standard self-attention, incurs a consistently high decision delay across all scales, hindering real-time edge responsiveness. Conversely, our DOS framework, driven by the $O\left(K\right)$ linear complexity of the UDC architecture, maintains a stable and low decision latency unaffected by massive concurrency. By achieving an over 3.4× speedup over DT while matching the highest throughput, DOS successfully overcomes both the computational collapse of heuristics and the latency bottlenecks of traditional attention mechanisms, enabling real-time, large-scale edge deployment.

5.4. Ablation Study: Efficacy of Priority-Aware Linearization

To evaluate the efficacy of the priority-aware linearization module, we compare the standard UDC_Priority model with a randomized baseline variant, denoted as UDC_Random, as shown in

Table 3. Ablation Study: Quantitative Comparison of Priority-Aware vs. Random Linearization. Bold formatting highlights the better results.

Workflow Scale	Model Variant	End Time (s)	Blocked Steps
500	UDC_Priority	4645.26	325.00
	UDC_Random	4650.07	408.00
1000	UDC_Priority	18,231.52	813.00
	UDC_Random	18,283.41	821.93
5000	UDC_Priority	18,254.12	2409.78
	UDC_Random	18,305.73	2447.34
10,000	UDC_Priority	22,367.97	4778.03
	UDC_Random	22,432.99	4803.56
20,000	UDC_Priority	52,206.01	9729.45
	UDC_Random	52,331.74	9995.00

. UDC_Random bypasses the multi-dimensional priority scoring logic by employing a naive topological sort that respects basic parent–child precedence but arbitrarily orders concurrent tasks.

Empirical trends across varying workflow scales consistently demonstrate severe performance degradation in both total makespan and resource-blocked steps when the priority mechanism is disabled. As the system scale expands, UDC_Random exhibits a substantial escalation in invalid scheduling steps. Random linearization scatters topologically correlated tasks across the decision sequence, causing the model to prematurely allocate constrained edge resources to non-urgent tasks and inducing severe head-of-line blocking.

Furthermore, because the causal convolutions within UDC rely on local context windows, random ordering severely obfuscates the overarching DAG topology. Without proximate dependencies, the sequence model fails to extract accurate structural inductive biases. Ultimately, these findings confirm that priority-aware linearization is indispensable for sequence models to effectively transition from one-dimensional token processing to topologically constrained DAG execution.

5.5. Scope and Future Research Directions

While the DOS framework demonstrates significant advantages in scalability and scheduling efficiency, its current implementation defines a specific operational scope that invites further extension. First, the evaluation assumes a steady-state service environment where containerized instances are pre-initialized. While this reflects many industrial high-throughput scenarios, the explicit integration of cold-start overheads remains a subject for future development to further refine latency predictions in highly dynamic edge settings.

Second, the MDP formulation utilized in this study relies on deterministic network profiles to ensure baseline consistency during the offline learning phase. Real-world continuum systems often exhibit stochastic fluctuations that may introduce latency modeling errors, suggesting that the incorporation of robust state representations would be a valuable addition to future model iterations.

Finally, while DOS effectively manages massive uniform concurrent scaling, extreme cases of workload distribution skew, such as bursty requests concentrated on a single critical service, may influence the packing efficiency of the sequence model. Future research will explore the potential of lightweight offline-to-online fine-tuning to adapt to these stochastic edge dynamics while strictly maintaining the linear-time inference advantages of the UDC architecture.

6. Conclusions

This paper proposes the Decoupled Offline Sequence-based (DOS) framework to resolve scalability and latency bottlenecks in cloud–edge workflow scheduling. By decoupling policy learning from deployment, DOS utilizes priority-aware linearization to transform DAGs into sequences. Driven by the UDC model with triplet-to-unary encoding, DOS captures long-horizon packing patterns. Evaluations on Alibaba workloads confirm its superiority under massive concurrency. Compared to heuristics, DOS mitigates resource fragmentation, reducing average makespan by up to 86%. Furthermore, DOS averts the systemic congestion of online Actor–Critic experts, decreasing resource-blocked steps by approximately 90%. Crucially, leveraging UDC’s linear complexity, DOS maintains scale-invariant inference latency. Achieving a >3.4× speedup against baseline Transformers, it eliminates quadratic overheads, guaranteeing real-time edge responsiveness. Future work will explore physical deployments and zero-shot transferability.