Modern distributed systems face growing challenges in scheduling workloads across heterogeneous cloud-edge infrastructures. Advanced pod orchestration techniques-pod cloning, dependency-aware scheduling, and parallel pod processing-are crucial for improving resource utilization, scalability, and fault tolerance. Pod cloning replicates workloads to handle spikes or failures, dependency management enforces correct task sequencing, and Kubernetes-native parallelism distributes tasks across concurrent pods. Despite their benefits, these strategies are seldom unified in adaptive, bio-inspired schedulers. This paper presents an emergent scheduler integrating cloning, dependency resolution, and parallelism within a swarm intelligence framework based on the Artificial Bee Colony (ABC) algorithm. Modeling the cluster as a multi-agent ecosystem, pods are treated as food sources managed via ABC's employed, onlooker, and scout phases. This enables decentralized decision-making that dynamically adjusts cloning, enforces dependencies, and tunes parallelism in response to real-time cluster states. Evaluated on a simulated edge-cloud testbed against random assignment, dependency-agnostic best-fit, and a static ABC baseline, our scheduler achieves superior latency and deadline satisfaction rates.
Eficient workload scheduling across heterogeneous cloud-edge systems is a growing challenge in
modern distributed environments. Key pod orchestration strategies—cloning, dependency-aware
scheduling, and parallel pod processing—optimize resource use, scalability, and fault tolerance. Pod
cloning dynamically replicates workloads to handle trafic spikes or failures, dependency management
ensures correct task sequencing, and parallel processing accelerates execution via Kubernetes-native
mechanisms [
The paper is structured as follows: Section 2 reviews related work. Section 3 details pod optimization strategies. Section 4 describes the system model and scheduler. Section 5 covers simulation setup and system behavior analysis. Section 5 discusses key findings, and Section 6 concludes with future directions.
Eficient cluster resource management has inspired approaches such as the oversubscription framework
in [
Autoscaling remains central [
We focus on fog-layer orchestration, selecting Figure 1: Pod cloning in the emergent
schedmaster agents on the cloud side and leveraging uler. (a) Conceptual framework
illusslack resources from rigid pods to support elastic trating clone generation. (b) Execution
workloads—an area underexplored by current workflow showing how cloned pods are
autoscaling. Edge-edge collaboration [
Pod cloning, dependencies, and parallel processing are key to optimizing workload management across distributed cloud–edge environments. This boosts resource utilization, reliability, and performance in interconnected systems, enabling applications to adapt to fluctuating demands and network conditions.
Pod Dependencies and Dynamic Resource Management: Managing pod dependencies ensures correct and eficient execution in Kuber- (a) (b) netes. In single deployments, independent pods enable horizontal scaling and resilience [15]. In Figure 2: Key pod orchestration concepts in the multi-deployment setups, dependencies—e.g., a emergent scheduler. (a) Parallel pod frontend relying on a backend or database—are processing in the emergent scheduler, critical. Kubernetes manages these via Services, where pods process simultaneously DNS, and network policies [15], enabling multi- based on shared constraints. (b) Intertier applications to remain scalable and fault- pod dependencies modeled in the emertolerant. Dynamic resource management tech- gent scheduler, including sequencing niques, such as pod cloning, integrate with de- and coordination requirements. pendency handling to enable autoscaling [16].
Thus, applications adjust replicas based on workload changes while preserving dependency constraints.
Pod Cloning and Autoscaling: doesn’t this already answer the Q: 3. how would observer mechanism work in kubernetes or computing infrastructure
Autoscaling dynamically adjusts computational resources to meet demand [16]. In Kubernetes, pod cloning replicates instances to scale horizontally during workload spikes, while load balancing distributes tasks for performance and fault tolerance. Cloning introduces scheduling complexity, as all replicas must respect original dependency rules. In complex workloads, this requires QoS-aware scheduling, as in [17], to ensure correct execution sequences. Techniques like topological sorting [18] help maintain execution order and optimize Figure 3: Overview of pod processperformance. ing logic in the emer
Parallel Pod Processing for Enhanced Performance: gent scheduler, integratParallel pod processing runs multiple pod instances concur- ing standard, cloned, parrently, similar to task parallelism [19]. Computationally in- allel, and dependent pod tensive tasks are split into subtasks and executed in parallel, behaviors. improving throughput and reducing latency—vital in areas like real-time analytics and AI training. This relies on application-level parallelism, as Kubernetes does not parallelize within a single pod. Developers must implement multithreading or multiprocessing [20] to exploit concurrent execution efectively.
Eficient orchestration combines parallel processing for speed, cloning for scalability and fault tolerance, and dependency management for correctness. Together, these strategies enable robust performance in complex, distributed systems.
We adopt the discrete-time, agent-based simulation framework with all scheduling policies described
in [
To handle the pod processing methods outlined in Section 3, we implement a logic layer that
pre-processes incoming pods. This step resolves their complexities—parallelism, cloning, and
dependencies—transforming them into the sequential input format required by the emergent scheduler [
Parallel Pod Processing: If a pod requires parallel processing, it is divided into sub-pods [19]
1 , 2 , . . . , , where is randomly selected from the range (1,10). Since each must be processed
by a single Edge Micro Data Center (EMDC), all its sub-pods are routed to the same queue, as described
in [
Pod Cloning: To simulate dynamic resource availability [16], the scheduler supports processing of cloned pods. If cloning is triggered, is replicated times, producing , , . . . , , with randomly chosen between 1 and 10. Clones are placed in the same queue and randomly ordered for sequential scheduling. Each clone is assigned an observer, , , . . . , , which monitors its status. Once one clone (e.g., ) finishes, its observer notifies the others, causing them to terminate—mimicking unexpected resource release in the emergent scheduler.
Pod Dependencies: When depends on other pods, meaning it cannot start until its prerequisites ifnish, dependencies are modeled as a DAG [ 18], with pods as nodes and dependencies as directed edges. For example, if depends on and , edges go from to and to .
To ensure the scheduler’s sequential input respects dependencies, we apply topological sorting [21]. This produces a linear order in which each pod appears after all its prerequisites. For example, if depends on and , and depends on , the resulting order could be , , , , guaranteeing that all constraints are satisfied before execution.
This section analyzes how system performance evolves under diferent scheduling strategies and
workload conditions. Through agent-based simulation, we evaluate the dynamic behavior of a distributed
edge environment subjected to varying pod elasticity levels, inter-pod dependencies, and trafic
intensities. The goal is to reveal how these factors influence pod satisfaction rate, i.e., how many of
the available resources in the EMDC can a pod use (as rigid) and reuse (as elastic) before its assigned
waiting time runs out [
Simulation Setup: The simulation environment is built using the MESA agent-based modeling
framework in Python [22]. Its modular design enables custom agent classes with specific behaviors and
decentralized execution, allowing each agent to operate independently. MESA’s built-in tools facilitate
modeling complex, interactive systems in a scalable way. Simulations run for 12,000 discrete time steps,
tracking pod satisfaction rate under varying pod arrival rates from 0.55 (light load) to 0.75 and 0.95
(heavy load). This progression allows us to evaluate the scalability and robustness of the bottom-up
scheduling strategy as the system approaches saturation. Two main factors are explored: pod elasticity
and pod coordination constraints. We compare datasets with 30% elastic pods and with 70% elastic pods.
Elastic pods provide scheduling flexibility but can also introduce overhead or contention with rigid
workloads. To examine how coordination complexity interacts with elasticity, three pod-level features
are included: parallel processing (10% of pods, grouped randomly between 1 and 10), cloning (10%),
and inter-pod dependencies (20%). These extensions are evaluated against baseline scenarios from [
Insights from Experimental Results: The results in Fig. 4–5 show pod elasticity, inter-pod dependencies, and varying influencing scheduling performance in terms of pod satisfaction rate. This is directly reflecting the cost of having introduced pod-dependency processing (compared against non-dependent pods), as well as the synchornization, i.e., pod coordination, costs.
Our analysis proceeds along three key dimensions: (1) the impact of pod elasticity, (2) the efect of increasing , and (3) the role of pod coordination constraints such as parallel processing, cloning, and inter-pod dependencies. These perspectives together provide a detailed understanding of the trade-ofs involved in bottom-up scheduling across diverse edge workload scenarios.
Satisfaction rate: (1) In panel (a), Fig. 4 (30% elastic pods), which includes pod dependencies, both the best-match and swarm intelligence (SI) strategies initially underperform compared to the random baseline. In panel (b), with independent pods, SI performs between random and best-match—a trend that continues as increases. (2) In panel (a), Fig. 5 (70% elastic pods), SI outperforms both baselines after timestep 5000, maintaining a satisfaction rate above 95%. For independent pods (panel b), all strategies achieve nearly perfect satisfaction, close to 100%, with minimal diferences across schedulers.
Elastic pods improve performance notably under high load and elasticity, but only with adaptive scheduling. The SI method shows strong resilience and consistently outperforms others in complex scenarios. For simpler, independent workloads, advanced strategies ofer little extra advantage.
Impacts and Observations: The simulation study reveals that pod elasticity and coordination requirements significantly influence satisfaction rates under varying trafic conditions. At moderate to high , elastic pods enable more flexible resource allocation, improving satisfaction rates—especially under the SI strategy. The addition of coordination mechanisms—such as parallel processing, cloning, and inter-pod dependencies—introduces extra complexity and can moderately reduce satisfaction in some scenarios. Nevertheless, the SI strategy shows resilience, maintaining relatively high satisfaction even under complex workloads. Interestingly, dependencies can sometimes improve stability in SI by preventing overly aggressive pod placement, resulting in more consistent satisfaction rates. 1.0 0.8 6000
Steps 6000
Steps (e)
Eficient workload scheduling across heterogeneous cloud-edge infrastructures is increasingly critical for modern distributed systems. Pod-level orchestration techniques—cloning, parallel processing, and dependency-aware execution—are essential for managing complexity, scalability, and fault tolerance, yet remain underutilized in decentralized schedulers. This work integrates these mechanisms into a swarm-intelligence-based scheduler using the Artificial Bee Colony (ABC) algorithm. Simulations (f) 6000
Steps (e) show that pod elasticity and coordination requirements strongly impact performance under high load. Elastic pods improve satisfaction rates with the SI strategy, though they may increase queue lengths. Best-match efectively controls queues but can struggle with slack estimation errors and complex coordination. Notably, dependencies like parallelism and sequencing can reduce queue buildup by moderating placement aggressiveness, providing a self-regularizing efect for SI. No single strategy dominates: best-match fits tightly constrained settings, while SI is more robust in dynamic, elastic, and uncertain environments. These insights guide the design of resilient, adaptive orchestration systems balancing flexibility, eficiency, and stability amid evolving workloads.
This work was performed in the course of the EU-project ACES supported by EU’s Horizon Europe under the grant agreement No. 101093126 (HORIZON-CL4-2022-DATA-01-02).
During the preparation of this work, the author(s) used Chat-GPT-4 and Grammarly in order to: Grammar and spelling check. After using these tool(s)/service(s), the author(s) reviewed and edited the content as needed and take(s) full responsibility for the publication’s content. Telecommunication Systems (MASCOTS), 2020, pp. 1–8. doi:10.1109/MASCOTS50786.2020. 9285953. [15] Kubernetes, Pods, 2025. URL: https://kubernetes.io/docs/concepts/workloads/pods/. [16] T. Lorido-Botran, R. N. Calheiros, R. M. Rodriguez, R. Buyya, C. Vecchiola, Autoscaling in the cloud: A survey, IEEE Transactions on Services Computing 8 (2015) 947–969. doi:10.1109/TSC. 2014.2350938. [17] J. Yu, R. Buyya, K. Ramamohanarao, Workflow scheduling algorithms for service-oriented cloud computing with blending of deadline and budget constraints, Proceedings of the 2008 IEEE International Symposium on Cluster Computing and the Grid (CCGRID) (2008) 427–436. doi:10. 1109/CCGRID.2008.46. [18] S. Even, Graph Algorithms, Cambridge University Press, 2011. Chapters on Directed Acyclic
Graphs. [19] S. Manvi, G. Shyam, Cloud Computing: Concepts and Technologies, 1st ed., CRC Press, 2021.
doi:10.1201/9781003093671. [20] P. S. Pacheco, An introduction to parallel programming, Morgan Kaufmann, 2011. [21] T. H. Cormen, C. E. Leiserson, R. L. Rivest, C. Stein, Introduction to Algorithms, 3rd ed., MIT Press, 2009. Section 22.4: Topological Sort. [22] D. Masad, J. L. Kazil, Mesa: An agent-based modeling framework, 2015. URL: https://github.com/ projectmesa/mesa/blob/master/CITATION.bib.