arXiv:2605.27106v1 [cs.DC] 26 May 2026
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum LAURI LOVÉN∗ , Future Computing Group, University of Oulu, Finland ROBERTO MORABITO, EURECOM, France ABHISHEK KUMAR, University of Jyväskylä, Finland SUSANNA PIRTTIKANGAS, AMD Silo AI, Finland JUKKA RIEKKI, Future Computing Group, University of Oulu, Finland SASU TARKOMA, University of Oulu and University of Helsinki, Finland The edge–cloud computing continuum demands self-management across autonomous administrative domains while honouring tenant- and operator-specified data sovereignty. We present Neural Pub/Sub, a federatedbroker autonomic substrate whose self-organising behaviour emerges from market-based price signals rather than centralised control. Each broker closes a MAPE-K loop over health and load monitoring, marginal-cost clearing-price analysis, placement over a polymatroidal feasibility region, federated cross-domain dispatch, and bounded-staleness peer price signals. The Plan step is anchored in a Walrasian convergence proposition: under gross-substitutes valuations on tree and series-parallel service-dependency DAGs, decentralised price-based allocation matches the welfare of a centralised oracle. On a 4-VM, 48-worker federated testbed (1005-run campaign with a fair-process-count sharded-oracle comparator), the market beats a single-process oracle by 2–4 % (45 of 45 per-seed wins) and stays within ±1.5 % of a four-shard oracle across all nine (pipeline, load) cells. Under saturation, round-robin completion collapses (98.8% → 22.4% → 3.3%) while the market preserves completion; the advantage decomposes into three Walrasian properties: information completeness, admission control, and price discovery. Federation withstands broker death and network partition (completion ≥ 98.7%), and sovereignty enforcement adds no measurable runtime overhead. CCS Concepts: • Computer systems organization → Self-organizing autonomic computing; Distributed architectures; • Computing methodologies → Multi-agent systems; • Theory of computation → Algorithmic mechanism design. Additional Key Words and Phrases: Autonomic computing, edge–cloud continuum, self-organisation, marketbased allocation, federated brokers, MAPE-K, sovereignty enforcement, Walrasian equilibrium, polymatroidal feasibility
1
Introduction
The edge–cloud computing continuum has become the default substrate for scientific and operational workloads, spanning instruments, edge sites, regional clouds, and centralised HPC facilities under independent administrative control [68]. Its complexity, heterogeneity, and dynamic nature place self-management on the critical path: workloads must be monitored, analysed, planned for, and dispatched without a human in every loop, and without a single coordinator with global visibility into all domains. This is the autonomic-computing problem [34, 36] restated for the continuum: a federation of autonomous administrative domains, each governed by its own operator, must self-organise to deliver multi-stage AI pipelines whose stages are placed across the continuum subject to capacity, latency, and sovereignty constraints. ∗ Corresponding author.
Authors’ Contact Information: Lauri Lovén, Future Computing Group, University of Oulu, Oulu, Finland, [email protected]; Roberto Morabito, EURECOM, Sofia Antipolis, France; Abhishek Kumar, University of Jyväskylä, Jyväskylä, Finland; Susanna Pirttikangas, AMD Silo AI, Oulu, Finland; Jukka Riekki, Future Computing Group, University of Oulu, Oulu, Finland; Sasu Tarkoma, University of Oulu and University of Helsinki, Oulu / Helsinki, Finland.
0:2
Lovén et al. domain boundary
pipeline
W
W
W
W
M E
K
A
P DOMAIN A node 1
DOMAIN A
node 2
DOMAIN B
node 3
P2P price-signal bus
Fig. 1. Conceptual overview of Neural Pub/Sub. A pipeline (gray) is dispatched stage-by-stage (orange) onto workers across administrative domains; each domain runs one broker closing a MAPE-K loop (expanded for Domain A). Brokers coordinate peer-to-peer over clearing-price signals (teal bus), without a central coordinator; local-only stages cannot cross a domain boundary (⊘). Schematic of the mechanism (Section 4); not the evaluation testbed (Section 5).
We address this problem with a federated-broker substrate, Neural Pub/Sub (Fig. 1), in which self-organisation is realised through market-based price signals rather than centralised coordination. Each domain runs a broker that monitors local workers, publishes a clearing-price summary to its peers, and dispatches stages of incoming pipelines either locally or across a federation overlay according to a price-based trade rule. The substrate’s autonomic behaviour closes a MAPE-K control loop [34, 36] (Section 4.4): per-broker health checks (Monitor), marginal-cost clearing-price computation (Analyse), placement decisions over a polymatroidal feasibility region (Plan), federated cross-domain dispatch (Execute), and shared peer subscription summaries with cached price signals as Knowledge. The continuum is instantiated as four edge-to-cloud administrative domains; in our testbed these correspond to O-RAN logical components, but the substrate is O-RAN-agnostic and applies to any four-domain edge-cloud topology. Existing self-management substrates address fragments of this problem but not its full scope. Container orchestrators (Kubernetes, KubeEdge [86]) and batch schedulers (Kueue [41], Volcano [81]) operate within a single administrative domain with a single control plane that has full worker visibility, foreclosing federation across vendor or jurisdictional boundaries. Stream-processing systems (Apache Kafka, Flink [17], Ray [56]) move data at scale but route by topic partitions, not by semantic content of service requests. ML pipeline orchestrators (Kubeflow [14], Argo Workflows, MLflow [87]) compose multi-stage pipelines but determine pipeline structure at design time and operate within a single cluster, with no mechanism for cross-domain placement, slice-aware QoS, or sovereignty enforcement. Self-adaptive software frameworks [19, 73, 82] have established the principles of MAPE-K and feedback-driven adaptation; this paper instantiates those principles for the continuum, with a market-based Plan step grounded in mechanism-design theory. Theoretical anchor. The architecture is grounded in a Walrasian convergence proposition imported from companion work [52]: the AI Service Markets framework [52] establishes that when service-dependency DAGs have tree or series-parallel structure, the feasible allocation region
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:3
is polymatroidal and a Walrasian equilibrium exists under gross-substitutes valuations [32, 35]. Decentralised price-based allocation can therefore, in principle, match the efficiency of a centralised oracle; in practice, at the scales we test, it can match a fair-process-count comparator (Section 5.5). The proposition motivates the Plan step’s mechanism design and is restated self-containedly in Section S2 of the electronic supplement. Sovereignty as a first-class self-management constraint. The substrate enforces tenant- and operatorspecified data sovereignty (which stage types may leave their originating domain) as a coordinatewise constraint on the feasibility region. The motivation is regulatory (GDPR transfers, EU AI Act conformity tiers, NIS2 supply-chain obligations), but the architectural treatment is generic: sovereignty is one instance of the broader self-management requirement that autonomic decisions honour domain-level invariants without external orchestration. Scope. The campaign reported here exercises a federated edge-cloud topology of four administrative domains on a single-data-centre telco-edge 4-VM testbed at the 5G Test Network Finland, Oulu (5GTNF) [69] with a single tc qdisc netem-emulated WAN link. The continuum claim is rather architectural and orchestration-layer than infrastructural: the broker substrate composes self-management across four-domain edge-to-cloud topologies, and the experimental evidence covers the orchestration loop’s behaviour under load, failure, partition, and sovereignty constraints. Cross-site WAN deployment, HPC-tier integration, asymmetric-trust / asymmetric-capacity / asymmetric-data-quality regimes, and live agent-runtime integration are out of scope and are discussed as future work in Section 6. Contributions. This paper contributes the federated distribution architecture for Neural Pub/Sub, the explicit MAPE-K mapping that frames it as an autonomic substrate, and a 1005-run experimental campaign across the edge-cloud continuum supplemented by a fair-process-count sharded-oracle comparator: (1) Autonomic federated-market substrate (Section 4). A four-domain federation of neural brokers that close a MAPE-K loop (Section 4.4) over marginal-cost clearing prices, polymatroidal placement, cross-domain dispatch, and peer subscription summaries. The Plan step operationalises Walrasian convergence (Proposition 3.1, citing [32, 35, 52]) for tree and series-parallel DAGs through five engineering refinements that are jointly sufficient for the empirical envelope tested (Section 4.3.2); per-component leave-one-out attribution is deferred. The substrate is composed as a static-DAG orchestration layer that can sit beneath dynamic agent runtimes (LangGraph [43], AutoGen [84], Anthropic MCP [7], Google A2A [30]); live agent-runtime integration and AI-augmented loop components are deferred. (2) Autonomic decentralisation matches centralised at equal process count and dominates the single-process oracle by 2–4 % (Section 5.5). The four-broker federated market is 2–4% lower mean latency than a single-process oracle across every (pipeline, load), with 45 of 45 per-seed wins (sign-test 𝑝 ≈ 2.8 × 10−14 , Hodges–Lehmann median −39.6 ms, 95% bootstrap CI [−44.1, −35.3] ms). A fair-process-count sharded-oracle comparator (4 coordinator processes, designated coordinator pulls peer state and runs find_placement over a merged topology) keeps the gap within ±1.5% across all 9 cells: the market dominates linear-chain cqi-chain (3/3, 1.4 %), the sharded oracle is marginally favoured at +5 ms / +2 ms on anomaly-sp at low / medium load, and ran-entangled ties at the cell level (1 market / 1 sharded / 1 tie). The inversion against the single-process oracle and the within-noise envelope at equal process count together support a sharper claim than “centralised is impractical”: at equal process count the autonomic substrate trades within ±5 ms of an idealised
0:4
Lovén et al.
centralised orchestrator while preserving vendor confidentiality, scaling without a single coordinator, and admitting formal Walrasian guarantees. (3) Self-management differentiates only under stress (Section 5.6). Under uniform load the market and three heuristic baselines converge to within ∼5 ms across every (pipeline, load) cell. Under saturation the conventional round-robin orchestrator’s completion rate (CR) collapses 98.8% → 22.4% → 3.3% across 𝜆 ∈ {5, 10, 15} pps while the market preserves CR. The advantage decomposes into three Walrasian properties (information completeness, admission control, price discovery) absent from non-autonomic baselines. (4) Autonomic robustness under broker death and network partition (Section 5.7). The federation withstands broker process kill, emulated edge–cloud network partition, and per-stage worker death across both edge sites: CR ≥ 98.7% across 75 federation and resilience cells. (5) Sovereignty enforcement adds zero observable runtime overhead (Section 5.8). Across 60 governance-grid runs (four enforcement scenarios × three pipeline types × five seeds) the mean latency under sovereignty constraints (stages tagged local-only cannot leave the originating domain) matches the unconstrained baseline to within 1– 3 ms, demonstrating that the autonomic substrate honours domain-level invariants without external orchestration cost. The remainder of this article is organised as follows. Section 2 surveys autonomic-computing foundations, distributed AI orchestration, semantic communication, pub/sub systems, and AI service marketplaces. Section 3 presents the system model including service-dependency DAGs and the Walrasian convergence result. Section 4 details the distribution architecture, including the MAPE-K mapping (Section 4.4) and sovereignty enforcement (Section 4.6). Section 5 evaluates the architecture across the 1005-run campaign and the fair-process-count sharded-oracle comparator. Section 6 discusses autonomic implications and limitations. Section 7 concludes. 2
Related Work
This section positions Neural Pub/Sub against five bodies of work: autonomic computing and selfadaptive systems (Section 2.1), distributed AI orchestration platforms (Section 2.2), publish/subscribe systems (Section 2.3), semantic communication (Section 2.4), and AI service marketplaces (Section 2.5). Section 2.6 closes with a positioning summary. 2.1
Autonomic Computing and Self-Adaptive Systems
The autonomic-computing programme introduced by Kephart and Chess [36] and elaborated in IBM’s architectural blueprint [34] frames complex distributed systems as collections of autonomic managers, each closing a MAPE-K (Monitor, Analyse, Plan, Execute, Knowledge) control loop over a managed resource. Self-adaptive software extends this with explicit attention to engineering practice: Salehie and Tahvildari [73] survey the landscape of self-adaptation under MAPE-K and adjacent reference models, Cheng et al. [19] lay out a research roadmap for software engineering of self-adaptive systems, and Weyns [82] integrates the contemporary toolbox (architecture-based adaptation, statistical model checking, learning-enabled adaptation) into a single textbook treatment. Parashar [68] reframes the autonomic problem for the edge–cloud continuum, identifying decentralised self-management as the load-bearing capability for science workloads spanning instruments, edge sites, and HPC centres. Neural Pub/Sub instantiates these principles concretely. Its MAPE-K control loop (Section 4.4) closes over per-broker health monitoring, marginal-cost clearing-price analysis, polymatroidal
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:5
placement planning, federated dispatch execution, and peer subscription summaries with boundedstaleness price signals as Knowledge. The Plan step is anchored in mechanism-design theory rather than feedback heuristics, distinguishing this work from the bulk of self-adaptive software that adapts via control-theoretic or rule-based loops without formal welfare guarantees. The continuumlevel framing aligns directly with Parashar’s autonomic vision [68]: domains are administratively independent, no single coordinator has global visibility, and self-organisation is the only mechanism by which heterogeneous, dynamic, multi-tenant workloads can be placed at scale. Saleh et al.’s MemIndex [72] addresses an adjacent autonomic problem in the same LM-based multi-agent pub/sub family: an adaptive, autonomous distributed memory-management layer that lets agents self-negotiate memory operations through an intent-indexed bipartite graph. MemIndex sits at the agent layer (each LM agent’s localized, dynamically updated memory of past user intents) while Neural Pub/Sub sits at the broker layer (each broker’s bounded-staleness view of peer subscriptions and prices); a fully integrated autonomic substrate would compose the two—LM agents using MemIndex for distributed memory while their pipelines are placed by the federated brokers of Section 4. 2.2
Distributed AI Orchestration
Orchestrating AI workloads across heterogeneous infrastructure has produced three families of systems. Telecom-orchestration standards (NFV-MANO [25], ZSM [26], ONAP [46], O-RAN SMO [61, 62]) describe the layers below (infrastructure lifecycle) and above (intent and exposure) autonomic placement substrates; Neural Pub/Sub is the autonomic substrate, complementary to but distinct from these management envelopes. Container orchestration. Kubernetes and its edge extensions (KubeEdge [86], K3s) manage container lifecycles, autoscaling, and scheduling. KubeEdge supports up to 100 000 edge nodes and provides offline operation with cloud synchronisation [86]. Modern batch schedulers Kueue [41] and Volcano [81] add priority queues, resource quotas, gang-scheduling, and admission control. All of these treat workloads as opaque containers within a single Kubernetes control plane: scheduling is based on resource requests and affinity labels, not the semantic content of the data flowing through the pipeline, and federation across administrative or vendor boundaries is not addressed. Stream processing and data pipelines. Apache Kafka provides durable, partitioned event streams; Apache Flink [17] adds stateful stream processing with exactly-once semantics; and Ray [56] offers a unified runtime for data processing, training, and serving with actor-based parallelism. Recent versions of Flink (2.2) introduce native ML inference operators and async LLM calls within streaming pipelines. These systems excel at high-throughput data movement and transformation but route events by topic partitions or explicit key assignments, not semantic content. ML pipeline orchestration and serving. Kubeflow Pipelines [14], Argo Workflows, and MLflow [87] compose multi-stage AI pipelines as developer-defined DAGs on Kubernetes; KServe [40] and Triton [60] serve individual models with autoscaling and dynamic batching. These share with Neural Pub/Sub the DAG abstraction for multi-stage workflows but differ in three respects: (i) pipeline structure is determined at design time by developer logic, not composed dynamically at runtime based on the semantic content of service requests; (ii) scheduling operates within a single Kubernetes cluster (one administrative domain), with no federation protocol or cross-domain placement; and (iii) placement decisions are based on resource requests and affinity labels, not on slice-level QoS constraints or governance policies. Neural Pub/Sub addresses a complementary problem: not how to execute a known pipeline within a managed cluster, but how to discover, compose, and place pipelines across autonomous domains based on the semantic content of service requests.
0:6
Lovén et al.
LLM-based agentic orchestration. LLM-based multi-agent frameworks [33] mark a static-todynamic transition at the task orchestration layer: statically declared graphs in AutoGen [84] and CrewAI [20] versus runtime-composed graphs in LangGraph [43] and the OpenAI Agents SDK [65], with typed cross-framework surfaces such as Anthropic MCP [7] and Google A2A [30]. All of them compose agent graphs at the task layer; Neural Pub/Sub composes resource-placement graphs at the orchestration layer, beneath the agent runtime. Saleh et al. [71] survey broker evolution for GenAI agents but identify no formal allocation mechanisms; model routers (OpenRouter [66], LiteLLM [13], RouteLLM [64], [59]) select endpoints by cost or latency without incentive compatibility or governance. Scope. Section 4’s mechanism requires the placement-call DAG to be known at allocation time, the regime of current orchestration substrates (Kubeflow, Argo, Airflow). Runtime DAG growth (e.g., LangGraph or A2A multi-step delegation) is supported by issuing one placement call per growth step; per-call welfare guarantees carry over but not as a single global guarantee across step sequences, since A2A-style multi-step delegation is non-monotonic-composition (a later step may revoke or rewrite earlier sub-task assignments) and the per-call Walrasian guarantees do not compose across such revocations. Dynamic-graph allocation is future work. Computing-continuum scientific-workflow orchestration. The Edge–HPC/Cloud continuum vision originates in the in-transit and in-network computing programmes of Beckman et al. [12] and is reframed as an autonomic-management challenge by Parashar [68]. Workflow systems for the science-end of the continuum — Pegasus [22], Parsl [9], Swift [83], CometCloud [38] — compose multi-stage scientific pipelines across edge instruments, intermediate analysis tiers, and HPC centres. They share Neural Pub/Sub’s pipeline-as-DAG abstraction and the cross-tier-placement question, but their decision substrate is centralised (a single workflow planner with global view), and welfare guarantees are not the design objective. In-transit computing positions the data path itself as a placement target [12]; the Neural Pub/Sub substrate is complementary, operating at the orchestration layer above the data plane. The HPC tier of the SI’s title is acknowledged but not exercised in the present campaign: the testbed is edge-cloud (4 administrative domains, 5GTNF), and HPC-tier integration — e.g., a Pegasus-style cross-DC workflow with a tier-3 supercomputing site — is deferred to follow-on work. The autonomic mechanism (federated brokers, market-based clearing, MAPE-K loop) is HPC-tier-compatible by design but unproven in that regime. Gap. The orchestration field has undergone a static-to-dynamic transition at the task layer (Airflow → LangGraph) but not at the resource layer (Kafka and Kubernetes remain static, singlecluster, semantically opaque), and the continuum-orchestration substrates above (Pegasus, Parsl, Swift, CometCloud) are centralised single-planner systems without welfare guarantees or federation across administrative boundaries. Neural Pub/Sub provides the resource-layer transition with formal guarantees, instantiating the autonomic-computing principles of [19, 34, 36, 68, 73, 82] in a federated, market-based substrate. 2.3 Publish/Subscribe Systems Publish/subscribe (pub/sub) decouples communicating endpoints in space, time, and synchronisation [27]. Topic-based systems (Kafka, MQTT) route by partition or channel name; content-based systems evaluate filters over message attributes [76]. Carzaniga et al. [18] introduced SIENA, a wide-area event notification service with predicate-based filters and an overlay routing algorithm that propagates subscriptions to minimise unnecessary forwarding. Subsequent work extended content-based pub/sub to structured P2P overlays [76], distributed hash tables, and elastic cloud deployments. These systems evaluate filters using Boolean predicates, attribute ranges, or regular expressions over structured fields. When subscriptions and events are expressed in unrestricted natural language (or carry multimodal content), paraphrases, synonyms, and contextual meaning escape predicate-based filters. Neural Pub/Sub replaces predicate evaluation with embedding-based
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:7
clustering (the matching layer is exercised in this paper as a frozen, pre-calibrated component; see Section 3.3) and propagates subscription summaries (centroid embeddings and cluster radii) rather than raw subscription text, enabling cross-domain routing in embedding space. 2.4
Semantic Communication
Semantic communication transmits the meaning of messages rather than their bit-exact form, moving the design objective from Shannon source/channel coding to goal-oriented effectiveness [70, 74]. Deep semantic codecs (DeepSC [85], DeepJSCC [15]) use Transformer-based joint sourcechannel coding under low-SNR conditions, and recent LLM-aware extensions [45, 88] couple semantic codecs with edge computing. These approaches optimise transport for the semantics of transmitted content; Neural Pub/Sub operates one layer up, on already-decoded content, deciding which receivers should act on it. The two layers compose: Section 3.3 sharpens the boundary by framing embedding-based matching as a routing-oriented rate-distortion problem. 2.5
AI Service Marketplaces and Resource Allocation
The continuum’s multi-stakeholder nature motivates market-based approaches to resource allocation. Service-function-chain placement and virtual-network embedding. Pipeline placement is closely related to service-function-chain (SFC) placement [11] and virtual-network embedding (VNE), both NP-hard with ILP and combinatorial-auction reductions. The combinatorial-auction angle inherits the Lehmann–Lehmann–Nisan / Nisan–Segal hardness picture [44, 58]: without grosssubstitutes structure, welfare-maximising allocation in combinatorial auctions is communicationcomplexity-hard and computationally NP-hard, justifying the integrator-encapsulation route to a GS-compatible representation rather than direct ILP. Neural Pub/Sub differs from classical SFC/VNE in three ways: (i) valuations are gross-substitutes by construction at the agent-facing layer (after integrator encapsulation), making price decomposition into a Walrasian mechanism well-defined; (ii) placement is decentralised across federated brokers using only summary information, trading optimality for vendor confidentiality; and (iii) governance constructs (Section 4.6) are absent from classical SFC/VNE formulations. Classical DAG-scheduling baselines. List-scheduling heuristics on static DAGs (HEFT [78], PEFT, CPOP) target makespan minimisation under a fixed task graph and a known set of heterogeneous processors with deterministic compute and communication costs [31, 42]. Neural Pub/Sub addresses a different problem class: pipelines arrive as a Poisson stream, the resource pool is shared across continuous arrivals, the allocation criterion is welfare (combining latency, queue depth, sovereignty, and federation cost) rather than makespan of a single DAG, and the decision is decentralised across federated brokers exchanging only price signals. HEFT-style baselines do not directly compose with a continuous-arrival welfare objective: makespan is undefined when the workload is open-ended, and HEFT’s centralised global-graph view contradicts the federated-broker constraint. Their absence from the comparison is therefore an honest scope choice, not an oversight; the centralised single-process oracle and fair-process-count sharded oracle play the role of the welfare-maximising upper-bound baselines that classical DAG-scheduling literature would call for. Edge resource markets and placement strategies. Auction-based mechanisms for edge resource allocation have been studied under various settings: truthful mechanisms for multi-attribute demand in mobile edge computing [47], pricing strategies for edge-cloud service provision, and RL-based task offloading formulated as Markov decision processes. These approaches allocate individual resources but do not model the dependency structure of multi-stage AI pipelines. At the placement level, common reallocation strategies (proximity-based, load-balanced, and random) exhibit fundamentally different trade-offs between latency minimisation and load distribution [50].
0:8
Lovén et al.
Under high load, load-sensitive strategies can trigger cascading superfluous reallocations (“reallocation storms”) where up to 15–20% of all tasks are reallocated needlessly [51]; simpler random strategies avoid this phenomenon because they do not react to load signals. This trade-off is directly relevant to our market-based mechanism, which uses price signals as a coordination layer between load-sensitive and proximity-aware placement (Section 4.3). The Walrasian equilibrium framework [32, 35] provides the theoretical foundation for price-based allocation under gross-substitutes valuations; Ausubel’s ascending clinching auction [8] and its polyhedral extensions [29] implement this for polymatroidal feasible regions. Service-dependency DAGs and sovereignty constraints. The AI Service Markets framework of [52] provides the formal substrate adopted in this paper: AI pipelines are modelled as service-dependency DAGs, polymatroidal feasibility regions arise under tree and series-parallel structures, and integrator encapsulation restores tractable allocation for arbitrary DAGs. We use this framework’s polymatroidal allocation, integrator encapsulation, and sovereignty-constraint formulation in our distribution architecture (Section 4). Multi-level governance composition — how partial enforcement composes across credibility levels under asymmetric trust, capacity, or data quality, formalised on the supermodular-lattice tradition [55, 79] — is the subject of forthcoming companion work; testing such composition predictions empirically requires heterogeneous-domain regimes and is out of scope for the homogeneous-load campaign of this paper. We adopt the sovereignty-as-coordinate-wise-bound formulation directly; multi-level credibility composition is left to follow-on work. Multi-agent orchestration and semantic routing. LLM-based multi-agent systems [33] have produced frameworks for agentic orchestration (AutoGen [84], CrewAI [20], OpenAI Agents SDK [65]); emerging work on edge-deployed multi-LLM systems (e.g., [53]) addresses trust, dynamic orchestration, and resource scheduling across heterogeneous edge nodes. These systems orchestrate agents (selecting which LLM handles a sub-task), but assume a shared runtime and do not address how agents discover and consume each other’s outputs across administrative boundaries. Manias et al. [54] apply embedding-based semantic routing to intent-based 5G core network management, achieving deterministic intent classification but limited to a fixed set of management actions. Programmable forwarding planes (P4Runtime [67], INT [37]) are data-plane orthogonal to the present scope. Gap. Existing market mechanisms allocate resources but lack a semantic interconnect layer for cross-domain coordination; cross-domain self-management substrates with provable welfare guarantees and runtime sovereignty enforcement have not been demonstrated in networked deployments. Neural Pub/Sub addresses these gaps: the broker federation integrates semantic matching with autonomic market-based allocation (Section 4.3), and the sovereignty module enforces tenant- and operator-specified data residency at zero measurable runtime cost (Sections 4.6 and 5.8). 2.6
Positioning
The Neural Router [49] is a single-broker semantic-matching system in the same line of work; the present paper specifies a federated-broker autonomic substrate that adds (1) an autonomic federated-market substrate grounded in Walrasian equilibrium theory [35, 52] and the MAPE-K reference model [34, 36]; (2) runtime sovereignty enforcement at zero measurable cost via the polymatroidal feasibility region; and (3) a tiered experimental design validating both infrastructure properties and scientific hypotheses. The result is a system that uniquely combines semantic content matching, multi-stage pipeline composition, cross-domain federation, sovereignty enforcement, and market-aware resource allocation under a single MAPE-K loop, distinguished from existing systems that support at most a strict subset of these dimensions (Kafka / Flink / Ray, MLflow / Kubeflow /
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:9
Argo and Kubernetes-side schedulers cover multi-stage but not cross-domain or semantic-aware allocation; SIENA [18] and content-based pub/sub [76] cover cross-domain but not multi-stage or sovereignty; DeepSC [85] and 5G-semantic-routing [54] cover semantic matching but not pipelines; AI Service Markets [52] cover multi-stage / sovereignty / market but lack semantic matching; LLM multi-agent [33] cover only partial slices). The original Neural Pub/Sub paradigm appeared in [48]; [71, 77] surveyed broker and AI-native interconnect frameworks. This paper provides the first formal specification of the autonomic distributed substrate that realises the vision, with the first empirical validation of decentralised-vs-centralised parity at equal process count. 3
System Model
This section establishes the formal foundations for the distribution architecture of Section 4. We first introduce service-dependency DAGs from the AI Service Markets framework [52] (Section 3.1), then state the Walrasian convergence result that motivates the architecture’s market mechanism (Section 3.2), describe the broker’s content-matching layer (Section 3.3), and define the design patterns that compose AI pipelines (Section 3.3.1). Symbols are introduced inline at first use. The clearing price 𝜋𝑘,𝑡 in Section 4.3 is distinct from the placement function 𝜋 defined in Section 4.1; the symbol’s role is unambiguous from context. 3.1
Service-Dependency DAGs
3.1.1 Resource Graph and Feasibility. We model the computing continuum as a set of service types R, ranging from infrastructure primitives (CPU, GPU, bandwidth) through data-processing and inference endpoints to compound agentic capabilities. Services exhibit structural dependencies: an inference service may depend on a pre-processing pipeline and a model-hosting service, each of which depends on underlying compute and storage. These dependencies are captured by a service-dependency DAG 𝐺 res = (R, 𝐸), (1) where a directed edge (𝑟, 𝑟 ′ ) ∈ 𝐸 indicates that service 𝑟 ′ depends on service 𝑟 . Each service 𝑣 ∈ R has a capacity 𝐶 𝑣 representing throughput (e.g., requests per second for an inference endpoint, cores for raw compute). Agents consume leaf services 𝐿(𝐺) ⊆ R, the terminal nodes of the DAG that represent externally accessible service endpoints. Each internal node 𝑣 constrains the aggregate throughput of its descendant leaves: the set of leaves reachable from 𝑣, denoted 𝐿𝑣 , satisfies ∑︁ 𝑥𝑙 ≤ 𝐶 𝑣 , (2) 𝑙 ∈𝐿𝑣
where 𝑥𝑙 is the throughput allocated to leaf 𝑙. The service-feasibility region is the intersection of all such constraints: Xres = 𝒙 ≥ 0 : 𝑥 (𝐿𝑣 ) ≤ 𝐶 𝑣 for every internal node 𝑣 , (3) Í where 𝑥 (𝑆) = 𝑙 ∈𝑆 𝑥𝑙 . 3.1.2 Polymatroidal Structure. The shape of Xres depends on the DAG topology. When 𝐺 res is a rooted tree or a two-terminal series-parallel network, the constraint families {𝐿𝑣 } form a laminar family (any two members are either nested or disjoint), and Xres is a polymatroid with rank function [52] ∑︁ 𝑓 (𝑆) = min 𝐶𝑣, (4) 𝐴
Ð
𝑣 ∈𝐴
minimised over antichains 𝐴 such that 𝑆 ⊆ 𝑣 ∈𝐴 𝐿𝑣 . A polymatroid is the polytope {𝒙 ≥ 0 : 𝑥 (𝑆) ≤ 𝑓 (𝑆) ∀𝑆 ⊆ 𝐿(𝐺)} for a normalised, monotone, submodular rank function 𝑓 [28]. This structure
0:10
Lovén et al.
enables efficient allocation via greedy algorithms or ascending auctions and incentive-compatible pricing under gross-substitutes valuations [32, 35, 52]. Why tree/SP DAGs induce laminar constraint families. A two-terminal SP digraph admits a binary parse tree [23, 80] whose leaves are 𝐿(𝐺); for every internal node 𝑣, 𝐿𝑣 coincides with the descending parse-tree leaves, so {𝐿𝑣 } is laminar on 𝐿(𝐺) (rooted trees are the single-edge-operand special case). Laminarity makes Eq. (4) monotone, normalised, and submodular, so Xres is a polymatroid [24, 28]. General DAGs may destroy laminarity: the canonical obstruction is the diamond (𝐾4 -minor), and the ran-entangled pipeline (Section 5.1) contains such a diamond, resolved by integrator encapsulation contracting each domain’s sub-DAG to a single composite node. 3.1.3 Integrator Encapsulation and Governance Constraints. The AI Service Markets framework [52] resolves general-DAG complexity through integrator encapsulation: an integrator manages a connected sub-DAG and exposes a composite service of scalar capacity 𝐶¯ 𝑗 = max-flow(𝐺 𝑗 ). (5) Contracting each integrator yields a quotient graph 𝐺 ′ ; when 𝐺 ′ is tree or SP, the agent-facing feasibility region is polymatroidal. Section 4 instantiates each domain’s broker as an integrator. Governance constraints impose coordinate-wise upper bounds 𝑢𝑙 ≤ 𝐶𝑙 on leaf allocations [52]; the governance-constrained region X𝑡 = Xres ∩ Xgov remains polymatroidal (intersection with coordinate-wise bounds preserves polymatroidal structure [28]). 3.2 Theoretical Anchor: Walrasian Convergence on Tree/SP DAGs The distribution architecture’s market mechanism (Section 4.3) is motivated by the following convergence result; the implemented mechanism is a marginal-cost approximation rather than the full polyhedral-clinching auction (gap discussed in Sections 4.3.2 and 5.5). The self-contained statement with conditions is in Section S2 of the electronic supplement. Proposition 3.1 (Walrasian convergence for tree/SP DAGs). Let 𝐺 res have tree or SP structure with laminar {𝐿𝑣 } on 𝐿(𝐺), and let agents’ valuations on leaf-allocation slices satisfy gross-substitutes (GS) [35]. Then a Walrasian equilibrium (𝒑 ∗, 𝒙 ∗ ) exists, 𝒙 ∗ maximises social welfare, and the equilibrium is computable in polynomial time via an ascending polyhedral-clinching auction on the polymatroidal feasibility region [8, 29]. The result combines tree/SP polymatroidal structure [28, 52] with Kelso–Crawford [35] and Gul– Stacchetti [32]. The GS condition is non-trivial: raw pipeline-bundle valuations are Leontief; the GS-compatible representation arises only after integrator encapsulation (Section 3.1.3) bundles multi-resource paths into composite slices with unit demand. 3.3
The Broker’s Content-Matching Layer
Each broker performs content matching by embedding subscriptions and incoming events into a dense vector space and assigning each event to subscriptions whose embeddings exceed a similarity threshold 𝜏 within 𝑘-means clusters. The single-broker matching layer’s design, calibration of 𝜏, embedding model, and optional LLM-based cluster compression are companion-paper concerns ([49]); the present paper exercises the matching layer as a frozen, pre-calibrated component so that the experimental signal is attributable to the distribution architecture (Section 4) rather than to matching-quality variation. Subscription cluster summaries (¯𝒆𝑘,𝑖 , 𝑟𝑘,𝑖 ) in Eq. (9) are rate-distortionstyle summaries of the underlying subscription set, complementary to semantic-communication transport codecs [15, 74, 85] (the matching layer operates one layer up, on already-decoded content, deciding which receivers should act on it). Live integration with dynamic agent runtimes (LangGraph [43], AutoGen [84], Anthropic MCP [7], Google A2A [30]) – where the matching layer
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:11
would route agent requests rather than pre-registered subscriptions – is deferred and is discussed as future work (Section 6). 3.3.1 Design Patterns and the Pipeline Placement Problem. Multi-stage AI workloads compose two design patterns into pipelines 𝐺 pipe = (𝑉 , 𝐸): a map operation (1 → 𝐹 → 1) transforms a publisher’s event through a processing function 𝐹 before delivery (e.g., classification, summarisation), and a funnel (𝑁 → 𝐹 → 1) aggregates events from multiple publishers (e.g., sensor fusion, federated aggregation). These patterns are analogous to MapReduce [21] but differ in two respects: the broker dynamically determines participation through semantic matching, and the patterns operate in streaming mode across the computing continuum. The polymatroidal feasibility argument of Section 3.1 subsumes both patterns: the parse-tree argument applies whenever the composed pipeline is series-parallel after integrator encapsulation. Given 𝐺 pipe and execution units distributed across multiple administrative domains, the pipeline placement problem finds a mapping 𝜋 : 𝑉 → N that assigns each stage to a node, subject to capacity, latency, and governance constraints, minimising a weighted combination of total inter-stage latency, resource utilisation imbalance, and administrative domain crossings; Section 4 formalises the constraints and presents the market-based, oracle, and heuristic placement algorithms. 3.4
Edge-Cloud Continuum Topology
The abstract multi-domain model of Sections 3.1 and 3.3.1 is instantiated as a four-domain edgecloud topology spanning two sites: • Edge site: Domains 𝑑 1 and 𝑑 2 . Low-latency compute co-located with edge devices. Withinsite latency < 1 ms. • Cloud site: Domains 𝑑 3 and 𝑑 4 . Abundant compute at higher latency. Within-site latency < 1 ms. A single WAN link (∼50 ms) connects the two sites, representing the midhaul/backhaul boundary of the continuum. Each domain 𝑑𝑘 ∈ D is administratively independent, with its own governance policy G𝑘 , compute pool N𝑘 , and trust relationships (the formal multi-domain model is given in Section 4.1). The topology creates the central autonomic placement question: should a pipeline stage execute at the edge (low latency, constrained compute) or in the cloud (high latency, abundant compute)? The price signals of Section 4.3 resolve this trade-off without global state. Section 5.1 maps the four logical domains onto a concrete O-RAN deployment for the evaluation, but the substrate is O-RAN-agnostic; any four-administrative-domain edge-cloud topology suffices. The evaluation exercises three representative 8-stage pipeline structures that span the polymatroidaltractability spectrum, parameterised by the non-modularity gap 𝛾 (the deficit of a constraint family from being laminar; 𝛾 = 0 for tree/SP DAGs, 𝛾 > 0 when the rank function fails submodularity, defined formally in Section 5.1): a linear chain (tree, 𝛾 = 0), where Walrasian convergence holds directly; a fan-in series-parallel pattern (SP, 𝛾 = 0), where convergence holds via the parse-tree argument of Section 3.1; and an entangled cross-tree fan-out/fan-in pattern (𝛾 > 0), where convergence holds only after integrator encapsulation contracts each domain to a composite node. The concrete instantiation of these as O-RAN cross-layer pipelines (cqi-chain, anomaly-sp, ran-entangled) is given in Section 5.1. 4
Distribution Architecture
The single-broker content-matching layer of Section 3.3 performs learned semantic matching within one administrative domain. The computing continuum spans multiple administrative domains, network slices, and geographic sites; closing an autonomic control loop over this continuum requires federating multiple broker instances into a coherent self-managing fabric. This section specifies
0:12
Lovén et al.
the distribution architecture, including the autonomic-market allocation mechanism (Section 4.3) that implements the Walrasian convergence prediction of Section 3.2, the sovereignty-enforcement scenarios (Section 4.6), and the explicit MAPE-K mapping (Section 4.4) that frames the substrate as an autonomic computing system in the sense of [34, 36, 68, 73]. 4.1 Formal Model 4.1.1 Domains, Brokers, and Execution Units. Let D = {𝑑 1, . . . , 𝑑𝑚 } be a set of administrative domains, each governed by an independent operator. Each domain 𝑑𝑘 contains: • A neural broker 𝑏𝑘 implementing the content-matching layer of Section 3.3; • A set of execution units N𝑘 = {𝑛𝑘,1, . . . , 𝑛𝑘,| N𝑘 | }, each with computational capacity 𝐶𝑘,𝑗 ; • A set of locally registered publishers P𝑘 and subscribers S𝑘 . 4.1.2 AI Pipelines as Service-Dependency DAGs. Following the AI Service Markets framework [52], an AI pipeline is modelled as a service-dependency DAG 𝐺 pipe = (𝑉 , 𝐸), where each node 𝑣 ∈ 𝑉 represents a processing stage and each directed edge (𝑣, 𝑣 ′ ) ∈ 𝐸 indicates that stage 𝑣 ′ depends on the output of stage 𝑣. Each stage 𝑣 has a computational demand 𝜌 𝑣 and an output data rate 𝜔 𝑣 . A Ð pipeline placement is a mapping 𝜋 : 𝑉 → 𝑘 N𝑘 that assigns each stage to an execution unit. A placement is feasible if: ∑︁ 𝜌 𝑣 ≤ 𝐶𝑘,𝑗 ∀𝑘, 𝑗 (6) 𝑣:𝜋 (𝑣)=𝑛𝑘,𝑗
and, for every edge (𝑣, 𝑣 ′ ) ∈ 𝐸: ℓ (𝜋 (𝑣), 𝜋 (𝑣 ′ )) ≤ 𝐿𝑣,𝑣 ′
(7)
where ℓ (·, ·) denotes the network latency and 𝐿𝑣,𝑣 ′ is the latency bound. 4.1.3
Governance Constraints. A governance policy G𝑘 for domain 𝑑𝑘 specifies: • Data sovereignty: a set T𝑘local ⊆ 𝑉 of stage types whose inputs must not leave domain 𝑑𝑘 ; • Trust requirements: for cross-domain edges, a minimum trust level 𝜏𝑘,𝑘 ′ between domains; • Audit obligations: stages processing regulated data must produce verifiable evidence bundles.
A placement 𝜋 is governance-compliant if it satisfies Eqs. (6) and (7) and: 𝑣 ∈ T𝑘local =⇒ 𝜋 (𝑣) ∈ N𝑘 4.2
(8)
Broker Federation
4.2.1 Federation Overlay. The brokers form a federation overlay F = (B, 𝐸 𝐹 ) where B = {𝑏 1, . . . , 𝑏𝑚 } and (𝑏𝑘 , 𝑏𝑘 ′ ) ∈ 𝐸 𝐹 if domains 𝑑𝑘 and 𝑑𝑘 ′ have established a federation agreement (mutual trust 𝜏𝑘,𝑘 ′ > 0). 4.2.2 Subscription Aggregation and Propagation. Each broker 𝑏𝑘 maintains a local subscription index: a set of clusters {𝑐𝑘,1, . . . , 𝑐𝑘,𝑝𝑘 } with associated embeddings and optimised subscription prompts. To enable cross-domain routing, brokers exchange aggregated subscription summaries with federation peers. Definition 4.1 (Subscription Summary). The subscription summary of broker 𝑏𝑘 is: 𝜎𝑘 = 𝒆¯𝑘,𝑖 , 𝑟𝑘,𝑖 , 𝜅𝑘,𝑖 : 𝑖 = 1, . . . , 𝑝𝑘
(9)
where 𝒆¯𝑘,𝑖 is the centroid embedding of cluster 𝑐𝑘,𝑖 , 𝑟𝑘,𝑖 is the cluster radius, and 𝜅𝑘,𝑖 is the available capacity.
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:13
4.2.3 Cross-Domain Routing, Consistency, and Recovery. When a publication arrives at broker 𝑏𝑘 and the local content-matching layer finds no adequate match, the broker initiates federated routing: embed publication, select peer-cluster pairs within distance threshold, apply governance filter, forward to selected brokers ranked by semantic distance, aggregate responses by confidence ¯ comparison cost per publication using precomputed centroids. The overlay is score; 𝑂 (𝑚 · 𝑝) asynchronous: peers exchange price summaries every 𝛿 prop = 10 s, with WANmax ≈ 50 ms giving a bounded staleness 𝐵 ≈ 10.05 s; routing decisions via Eq. (13) use stale-but-bounded prices, corrected by the next exchange. Each federated dispatch carries a per-RPC timeout 𝜏fed = 5 s; on miss, the originating broker treats the peer as unreachable and falls back to local-only placement. The same 𝛿 prop -period channel doubles as the broker-liveness signal: after 𝑘 miss = 3 consecutive failed pushes (≈ 30 s) the peer is marked unhealthy, its 𝜎𝑘 and price signal evicted, and it is excluded from routing until a recovery probe (every five rounds) succeeds; on partition healing, brokers exchange the last 𝐵 s of price history and resume periodic exchange (no global rollback). Consistency model and delivery semantics. The federation overlay’s Knowledge layer (peer subscription summaries 𝜎𝑘 , peer price signals; Section 4.4) is bounded-staleness eventually consistent in the sense of probabilistically-bounded staleness [10]: any read at broker 𝑏𝑘 reflects a peer state at most 𝐵 seconds old, and across-peer convergence is guaranteed within one 𝛿 prop period after the network heals. Subscription propagation and price exchange are POST-only HTTP RPCs with at-most-once delivery semantics (no retries on the application side) and no global ordering guarantee; the orchestration result is therefore conditional on the assumption that loss / reorder are below the levels at which the 𝑘 miss = 3 failover regime begins to misclassify peers. Pipeline dispatch from broker to local worker is at-least-once with idempotent stage handlers (worker-side deduplication on pipeline ID), and the within-round ledger ℓadd (Section 4.3.2) is single-writer per broker and committed atomically at end-of-round. Cross-broker reservation conflicts cannot occur by construction: each worker is registered with exactly one broker, so two brokers cannot dispatch to the same worker concurrently; cross-broker over-allocation onto a domain (rather than a worker) is bounded by a single pipeline’s stage count and settled within 𝐵 + 𝛿 health , consistent with the asynchronous, eventually-consistent semantics of Theorem 3.1. 4.2.4 Integrator Encapsulation. Each domain’s broker acts as an integrator [52]: it encapsulates the domain’s internal service-dependency structure into a composite service with scalar capacity: 𝐶ˆ𝑘𝑡 = max -flow 𝐺𝑘𝑡 (10) ˆ where each domain is a The federation-level allocation operates on the quotient graph 𝐺ˆ = ( D̂, 𝐸) single node. When 𝐺ˆ is tree or series-parallel, the federation-level feasibility region is polymatroidal (Theorem 3.1), and efficient mechanisms apply. 4.3
Market-Based Decentralised Allocation
The market mechanism enables pipeline placement across domain boundaries using price signals rather than global state. This operationalises the Walrasian convergence result of Theorem 3.1: for tree/SP pipeline DAGs, the price-based mechanism converges to the welfare-maximising allocation. 4.3.1 Bids, Clearing Prices, Federation, and Trade Decision. Each worker 𝑛𝑘,𝑗 in domain 𝑑𝑘 submits a bid WorkerBid(𝑛𝑘,𝑗 , 𝑡) = 𝑐𝑘,𝑗,𝑡 for each stage type 𝑡, with 𝑐𝑘,𝑗,𝑡 the opportunity cost increasing in utilisation (congestion pricing). The domain broker 𝑏𝑘 computes per-stage-type clearing prices via marginal cost pricing, 𝜋𝑘,𝑡 = 𝑐𝑘,(𝑑𝑡 ),𝑡 ,
(11)
0:14
Lovén et al.
Algorithm 1 Market-Based Pipeline Placement Require: Pipeline 𝐺 pipe = (𝑉 , 𝐸), local domain 𝑑𝑘 , worker bids, price signals from federation peers, WAN cost 𝑤 WAN Ensure: Placement 𝜋 : 𝑉 → N or rejection Concurrency: round-synchronous; bids are collected before clearing, peer prices are read-only within a round, and pipelines are processed in arrival order at each broker. 1: Collect WorkerBids from all workers in 𝑑𝑘 2: Compute clearing prices 𝜋𝑘,𝑡 for each stage type 𝑡 via marginal cost pricing (Eq. (11)); equal-cost bids ordered by ascending worker ID 3: Broadcast PriceSignal(𝑑𝑘 ) to federation peers 4: for each stage 𝑣 ∈ 𝑉 in DAG topological order (Kahn’s, ties by ascending stage ID) do 5: 𝑡 ← type(𝑣) 6: for each remote domain 𝑑𝑘 ′ with price signal do 7: if 𝜋𝑘 ′ ,𝑡 + 𝑤 WAN < 𝜋𝑘,𝑡 then 8: Mark 𝑣 for remote placement in 𝑑𝑘 ′ 9: end if 10: end for Assign 𝑣 to arg min over feasible workers of cost-per-stage in the chosen domain (ties 11: broken by ascending worker ID) 12: Accumulate cost 13: end for 14: if total cost > pipeline value budget then 15: return rejection 16: end if 17: return placement 𝜋 where 𝑐𝑘,(𝑑𝑡 ),𝑡 is the 𝑑𝑡 -th cheapest worker’s cost for stage type 𝑡 and 𝑑𝑡 = min(demand𝑡 , supply𝑘,𝑡 ). Brokers exchange price signals PriceSignal(𝑑𝑘 ) = {(𝑡, 𝜋𝑘,𝑡 ) : 𝑡 ∈ stage types}
(12)
alongside subscription summaries (preserving worker-identity privacy). For each stage of type 𝑡, the originating broker compares local and remote prices: ( remote if 𝜋𝑘 ′ ,𝑡 + 𝑤 WAN < 𝜋𝑘,𝑡 , trade(𝑡) = (13) local otherwise, with 𝑤 WAN the WAN transfer cost; ties prefer local placement, and the pipeline is accepted if total cost ≤ pipeline value budget. Algorithm 1 summarises the procedure (runs per allocation epoch). The clearing prices 𝜋𝑘,𝑡 approximate Walrasian prices: they reflect the marginal cost of the scarce resource. For tree/SP DAGs where workers exhibit GS valuations (single stage type, unit demand), the price adjustment converges to the equilibrium prices of Theorem 3.1; Section 5 tests how closely this practical mechanism matches the centralised oracle. 4.3.2 Implementation refinements. The Walrasian mechanism in Theorem 3.1 is realised through five coupled components, each addressing a distinct gap that emerged during testbed validation: (i) speed-scaled bids 𝑏𝑖 = 𝑏 0 𝑠𝑖 at registration encode intrinsic worker capability (𝑠𝑖 = relative processing speed) into the price signal independent of load (utilisation-based pricing alone produces only ∼ 2 ms price gaps at 𝜆 = 5 pps, below any realistic WAN cost); (ii) M/M/1 dynamic congestion pricing
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum Monitor
Analyse
HB / load probes
M/M/1 clearing 𝜋𝑘,𝑡
0:15
Knowledge 𝜎𝑘 , peer prices (𝐵 -stale)
Execute
Plan
trade rule (13)
Algorithm 1
Fig. 2. MAPE-K control loop closed at each broker. Solid arrows: control flow per allocation epoch. Dashed arrows: Knowledge updates and reads. Knowledge is bounded-staleness (Section 4.2.3, 𝐵 ≈ 10.05 s) rather than synchronously consistent.
computes per-worker cost 𝑏𝑖 cost𝑖 = , 1 − 𝜌𝑖
ℓ𝑖 𝜌𝑖 = min , 0.99 , 𝑐𝑖
(14)
with the 𝜌𝑖 ≤ 0.99 cap inside the formula bounding costmax = 100 𝑏𝑖 (orders of magnitude above 𝑤 WAN , so WAN-vs-local trade is dominated by genuine queue-depth signal); (iii) federated price exchange (POST /federation/price-signal every 𝛿 prop s, alongside subscription-summary propagation) ensures routing decisions reflect federation-wide scarcity rather than only the local domain’s clearing price; (iv) within-round load reservation via a per-round commitment ledger ℓadd : U → R ≥0 tests 𝜌 𝑣 ≤ 𝑐𝑢 − ℓ𝑢 − ℓadd (𝑢) rather than the pre-round residual snapshot, preventing an 8-stage cqi-chain pipeline from over-committing a single cheap worker; (v) health-check utilisation synchronisation (one probe per worker per 𝛿 health = 5 s) keeps each broker’s view of ℓ𝑖 — the input to Eq. (14) — responsive to actual worker queue depth rather than a stale local estimate. The five are jointly sufficient for the empirical envelope tested in Section 5: each component addresses a concrete failure mode encountered during testbed validation, and the campaign reported here exercises the substrate with all five engaged. A per-component leave-one-out attribution table — which would isolate the marginal contribution of each refinement — is deferred to follow-on work; the campaign’s three-property Walrasian decomposition (information completeness, admission control, price discovery; Section 5.6) instead isolates which Walrasian properties are exercised, not which engineering refinements are individually load-bearing. 4.4
Autonomic Control Loop (MAPE-K)
The components of Sections 4.1 to 4.3 jointly close a MAPE-K control loop [34, 36] at each broker, framing Neural Pub/Sub as an autonomic substrate in the sense of self-adaptive software [19, 73, 82] (Fig. 2). The five elements are realised concretely as follows. Monitor. Each broker tracks the health and load of its local workers via the periodic probe loop (𝛿 health = 5 s, Section 4.3.2) and tracks federation peers via the heartbeat-based partition detector (𝛿 prop = 10 s exchange period, 𝑘 miss = 3 consecutive misses; Section 4.2.3). The monitor produces per-worker queue depth ℓ𝑖 (input to Eq. (14)) and per-peer liveness, both with bounded latency. Analyse. The broker computes per-stage-type clearing prices 𝜋𝑘,𝑡 from worker bids using the M/M/1 sojourn-time cost model (Eqs. (11) and (14)). This is the marginal-cost analysis stage of the autonomic loop: it converts raw monitored state into decision-relevant signals, with the 𝜌𝑖 ≤ 0.99
0:16
Lovén et al.
cap providing bounded admission control. Speed-scaled bids (Section 4.3.2) ensure the analysis differentiates intrinsic worker capability from current load. Ð Plan. Algorithm 1 computes a placement 𝜋 : 𝑉 → 𝑘 N𝑘 over the polymatroidal feasibility region X𝑡 = Xres ∩ Xgov (Section 3.1). Planning is local to each broker and uses cached peer prices for cross-domain trade decisions (Eq. (13)). Theorem 3.1 guarantees that, under tree/SP DAG structure and gross-substitutes valuations, the planned allocation converges to the welfare-maximising Walrasian equilibrium; the marginal-cost approximation gap is characterised in Section 5.5. Execute. The planned placement is dispatched as federated cross-domain HTTP calls (per-RPC timeout 𝜏fed = 5 s, Section 4.2.3), with the per-round reservation ledger ℓadd committing atomically at end-of-round (Section 4.3.2). Execution updates the local Monitor state (worker load reports) and pushes a fresh price-signal vector (POST /federation/price-signal) to peers, closing the loop. Knowledge. The shared Knowledge layer holds two artefacts: per-peer subscription summaries 𝜎𝑘 = {(¯𝒆𝑘,𝑖 , 𝑟𝑘,𝑖 , 𝜅𝑘,𝑖 )} (Eq. (9)) for cross-domain semantic routing, and cached peer price signals PriceSignal(𝑑𝑘 ′ ) (Eq. (12)) for cross-domain trade decisions. Both are bounded-staleness rather than synchronously consistent: the staleness bound 𝐵 = 𝛿 prop + WANmax ≈ 10.05 s (Section 4.2.3) is the load-bearing operational parameter that decouples the autonomic loop from synchronous federation handshakes. The within-round reservation ledger and the next-round price exchange jointly absorb the staleness, consistent with the eventually-consistent semantics of Theorem 3.1. The MAPE-K mapping makes three engineering claims explicit. First, the loop is decentralised: every broker closes its own loop, with no global coordinator on the critical path. Second, the loop is economically grounded: the Analyse and Plan stages use mechanism-design primitives (marginal-cost clearing, polymatroidal feasibility, Walrasian equilibrium) rather than rule-based heuristics or feedback-control gain tuning, distinguishing this work from the bulk of self-adaptive substrates. Third, the loop is bounded-staleness rather than strongly consistent: the Knowledge layer’s 𝐵-second staleness is a designed parameter, not a defect, and the autonomic robustness results of Section 5.7 directly test loop behaviour under broker death and network partition. 4.5
Tiered Placement Capabilities and Slice-Aware Cost
The architecture supports a hierarchy of placement capabilities for controlled experimental comparison: oracle (single broker, full global visibility, congestion-aware DP/greedy on Eq. (15); efficiency upper bound), conventional centralised round-robin (single broker, full visibility but no cost-optimised placement; conventional-orchestrator baseline), market (four brokers, price-signal coordination via Algorithm 1; Theorem 3.1’s mechanism), and three heuristics (locality-only, latency-greedy, spillover). All five honour slice constraints 𝜋 (𝑣) ∈ N 𝑠 (𝑣) as a feasibility filter (5G/6G network slices [2, 4–6] partition the physical infrastructure; we model two QoS tiers, low-latency 1 ms and best-effort 5 ms added processing delay, labelled URLLC/eMBB in the evaluation). The placement cost function is ∑︁ ∑︁ 𝜌 𝑣 ∗ ′ 𝜋 = arg min 𝛼 ℓ 𝜋 (𝑣), 𝜋 (𝑣 ) + 𝛽 + 𝜁 {𝑘 : ∃𝑣, 𝜋 (𝑣) ∈ N𝑘 } (15) 𝜋 𝐶 ′ 𝑣 ∈𝑉 𝜋 (𝑣) (𝑣,𝑣 ) ∈𝐸
with three terms for inter-stage latency, per-stage resource utilisation, and domain crossings. The placement-cost weight 𝜁 is distinct from the non-modularity gap 𝛾 of Section 5.1. Tree-structured pipelines admit a 𝑂 (|𝑉 | · |N | 2 + |B| log𝑊 ) DP solution where |B| ≤ 𝑚 · |T | · 𝑊 is the bid-space cardinality and 𝑊 = max𝑘 |N𝑘 |; general DAGs use greedy topological assignment in 𝑂 (|𝑉 | · |N | + |B| log𝑊 ). When 𝜁 > 0, the domain-crossings term breaks tree decomposition by a 2 | D | factor; with |D | = 4 in the deployment this is bounded by 16 and dominated by the polynomial term at the testbed scale (|𝑉 | = 8, |N | = 48).
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
4.6
0:17
Sovereignty Enforcement Scenarios
The sovereignty module implements four enforcement scenarios at the site level (edge {𝑑 1, 𝑑 2 } and cloud {𝑑 3, 𝑑 4 } each either enforce or do not): Scenario A (neither enforces), B (edge-only), C (cloud-only, symmetric to B), D (both enforce). The 2×2 design exercises sovereignty enforcement at increasing site-level coverage and is used in Section 5.8 to verify that enforcement adds no measurable runtime cost across the four regimes. 4.7
Failure Handling and Scaling
If a broker fails, federation peers detect via heartbeat timeouts and continue routing using cached summaries; publishers/subscribers in the failed domain re-register with the nearest peer. When an execution unit fails, the local broker detects via health-check and triggers stage re-placement to an alternative node. The funnel pattern supports three failure modes: wait (buffer and timeout), proceed (partial inputs), or abort (signal failure downstream); per-funnel choice is part of the pipeline’s fault-tolerance policy [17]. For large-scale deployments (𝑚 > 50 domains), hierarchical federation reduces propagation cost from 𝑂 (𝑚 2 ) to 𝑂 (𝑚); summary compression via super-clustering further reduces overhead, and the architecture’s overhead (summary propagation, cross-domain routing, placement optimisation) does not require LLM invocations. 5
Evaluation
We evaluate Neural Pub/Sub on a 4-VM, 4-domain, 48-worker testbed deployed on the 5G Test Network Finland (5GTNF). The evaluation is organised around four headline findings introduced in Section 5.3, supported by an infrastructure-validity check that establishes the experimental substrate as sound. Per-cell detail is in the electronic supplement. 5.1
Scenario: O-RAN Cross-Layer Pipelines on the Edge-Cloud Continuum
We instantiate the four edge-cloud-continuum domains as DU / CU+near-RT RIC / non-RT RIC / SMO from the O-RAN architecture [61]; the substrate is O-RAN-agnostic, and any four-administrativedomain edge-cloud topology suffices. In multi-vendor deployments these components may be supplied by different vendors, creating genuine administrative boundaries with distinct governance policies, compute resources, and QoS characteristics; in 5G integrations, the standardised NWDAF service-based interfaces [1, 3] (Nnwdaf_AnalyticsInfo, EventsSubscription, MLModelProvision) are the natural substrate above which Neural Pub/Sub composes its cross-domain placement layer. We map the four logical domains to a two-site topology representing the edge-cloud continuum: • Edge site (2 VMs): Domain 𝑑 1 (DU, 12 URLLC workers) and Domain 𝑑 2 (CU + near-RT RIC, 12 mixed URLLC/eMBB workers). Represents cell-site and edge compute. • Cloud site (2 VMs): Domain 𝑑 3 (non-RT RIC, 12 eMBB workers) and Domain 𝑑 4 (SMO, 12 best-effort workers). Represents regional and central cloud. Within each site, brokers federate over LAN (<1 ms). Between sites, a single WAN link (∼50 ms, emulated via tc qdisc netem) represents the midhaul/backhaul boundary. This creates the placement question on which the architecture is judged: should a pipeline stage execute at the edge (low latency, constrained compute) or in the cloud (high latency, abundant compute)? Three 8-stage pipeline types arise naturally from O-RAN cross-layer optimisation use cases, each with identical stage count but different DAG structures: (1) CQI Prediction Chain (tree, 𝛾 = 0): DU:raw_cqi → DU:denoise → CU:normalise → CU:feature_extract → RIC:predict → RIC:validate → nRT:aggregate → SMO:report. Linear chain crossing all 4 domains. 8 stages, 7 edges.
0:18
Lovén et al.
(2) RAN Anomaly Detection (series-parallel, 𝛾 = 0): Four parallel sources (2 DU + 2 CU) converge at the near-RT RIC for fusion, classification, alerting, and logging. 8 stages, fan-in only. (3) RAN Intelligence Suite (entangled, 𝛾 > 0): Cross-domain fan-out from CU:feature_extract to both RIC:cqi_predict and RIC:anomaly_detect, with cross-tree fan-in from RIC + non-RT RIC at SMO:handover_optimise. 8 stages, 10 edges. Shared stages and diamonds create a non-zero non-modularity gap 𝛾. The three pipeline templates have identical per-stage compute demand 𝜌 𝑣 across templates (each stage type carries the same configured processing time), so the latency differences reported in Sections 5.5 and 5.6 are attributable to DAG structure (chain depth, fan-out, cross-tree dependencies) rather than to per-stage compute heterogeneity. 5.2
Testbed and Configuration
The campaign comprises an infrastructure-validity check on a single 5GTNF virtual machine (University of Oulu; 4 CPU cores, 8 GB RAM, Docker CE 29.3 on Ubuntu 24.04) with 2 domains and 5 workers, and a main 4-VM campaign with one VM per O-RAN domain (VM1=DU/URLLC; VM2=CU+near-RT RIC/URLLC+eMBB; VM3=non-RT RIC/eMBB; VM4=SMO/best-effort), 12 workers per VM (48 total), 4 brokers, identical hardware (4 cores / 8 GB / Ubuntu 24.04). Within-site latency: <1 ms (shared LAN). Cross-site WAN: 50 ms delay + 5 ms jitter (emulated via tc qdisc netem between VM2 and VM3). Slice QoS emulated per worker group: URLLC at 1 ms, eMBB at 5 ms added processing delay. Each VM runs one Docker Compose stack with its broker and ∼12 workers using network_mode: host; brokers federate via the summary propagation protocol. Placement-cost weights (𝛼, 𝛽, 𝜁 ) in Eq. (15) are set to (1, 1, 1) in all reported runs; the substrate accepts arbitrary weights at deployment time, and operator-specific tuning is left to deployment, not load-bearing for the present claims. Three 8-stage O-RAN pipeline templates are used (Section 5.1). Poisson arrivals with rate 𝜆 ∈ {2, 5, 10} pps for the main allocation grid, distributed across domains (each domain’s workload generator targets its local broker). Each configuration runs with five independent seeds. Warmup: 4 minutes (increased for 48-worker steady state). Measurement window: 10 minutes. The ablation programme uses additional rates 𝜆 ∈ {5, 8, 10, 15, 50} pps to sweep across and beyond the empirical saturation knee at ∼13.8 pps (calibrated via a dedicated sweep, scripts/calibrate_saturation.py). The saturation knee (∼13.8 pps, 95% CI [12.5, 14.6] via bootstrap on a piecewise-linear segmented regression of mean CR vs 𝜆) is calibrated by sweeping 𝜆 ∈ {5, . . . , 16, 18, 20, 25, 30, 40, 50} pps under round-robin placement; the knee is a round-robin property, and the market’s admission control pushes its own knee beyond 50 pps (Section 5.6). 5.3
Methodology Overview and Findings Summary
The 4-VM campaign comprises 1005 runs across seven phases (∼129 hours of cluster wall clock): a 450-run ablation programme isolating Walrasian mechanism properties under saturation, heterogeneity, and worker failure; a 40-cell baseline phase reproducing infrastructure-validity at 4-VM scale; a 50-cell slicing phase exercising governance and slice variants; a 50-cell worker-failure resilience phase; a 60-cell stress phase combining load and failure injection; a 330-cell main market phase comprising the 270-cell allocation grid (six strategies × three pipelines × three loads × five seeds) and the 60-cell governance grid (four enforcement scenarios × three pipelines × five seeds); and a 25-cell federation phase (broker kill, network partition, governance, neural, static). A prior single-VM Tier-1 validation (transport orthogonality, slice awareness, governance overhead, failure resilience) on a smaller substrate supports the infrastructure check; we summarise it inline in
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:19
Section 5.4 and treat the 4-VM baseline as its production-substrate reproduction. The campaign maps to four headline findings; per-cell detail is in the electronic supplement. (1) Autonomic decentralisation matches centralised at equal process count and dominates on linear-chain pipelines. The federated market beats the single-process oracle by 2–4% in every (pipeline, load) cell (45 of 45 per-seed wins, sign-test 𝑝 ≈ 2.8 × 10−14 , Hodges–Lehmann median −39.6 ms, 95% bootstrap CI [−44.1, −35.3] ms); a fair-process-count sharded-oracle comparator (4 coordinator processes) keeps the gap within ±1.5% across all 9 cells, with the market dominating on cqi-chain (3/3) and trading within ±5 ms on anomaly-sp and ran-entangled (Section 5.5). (2) Strategy choice differentiates only under stress. Under uniform load, market ≈ locality ≈ latency-greedy ≈ spillover within ∼5 ms; under saturation, heterogeneity, or worker failure at saturating load, only the market preserves performance. The advantage decomposes into three Walrasian properties: information completeness, admission control, price discovery (Section 5.6). (3) Federation handles broker death and network partition with completion rate ≥ 98.7% across 75 federation and resilience cells (Section 5.7). (4) Sovereignty enforcement adds zero observable runtime overhead. Across 60 governancegrid runs (four enforcement scenarios × three pipeline types × five seeds), mean latency under sovereignty constraints matches the unconstrained baseline to within 1–3 ms, demonstrating that the autonomic substrate honours domain-level invariants without external orchestration cost (Section 5.8). 5.4
Infrastructure Validation
Before the main findings, we establish four substrate-soundness results. (i) Transport orthogonality: at 𝜆=5 pps single-VM, per-seed latency differences between HTTP and Kafka are < 1 ms for round-robin and random placements; neural placement adds ∼8 ms under Kafka relative to HTTP (Kafka consumer dispatch, < 2% of total). All strategies achieve near-identical performance under homogeneous single-site conditions (∼1231 ms median, ≥ 99% completion). (ii) Slice-aware placement reduces median latency by 15% under HTTP (1233 vs 1450 ms) and increases throughput 5× in the equalised B1eq-vs-B2 comparison. (iii) Governance enforcement adds 0% latency overhead vs unconstrained slice-aware placement (within 1 ms across HTTP and Kafka). (iv) Worker-failure recovery: HTTP achieves 100% pipeline completion at 𝑡 = 5 min worker kill; Kafka shows 1.1% completion loss attributable to consumer-group rebalancing rather than the placement algorithm. The 4-VM baseline (40 runs) and slicing (50 runs) phases reproduce these confirmations on the production substrate at 100% completion across all strategies and transports, with the neural-overhead vs round-robin gap shrinking to ≈6 ms (0.5%) and the HTTP-vs-Kafka mean-latency gap to ≤ 1 ms across all five placements; governance enforcement reproduces the zero-overhead result across all 50 slicing cells. 5.5
Decentralisation Beats the Centralised Baseline
The efficiency comparison is: 𝜂 market , (16) 𝜂 oracle where 𝜂 is social welfare (sum of pipeline values minus placement costs). With pipeline values held constant across strategies, 𝜂 is monotone in mean end-to-end latency, so we report mean latency directly. The fair-process-count sharded comparator is a 4-broker centralised orchestrator with a designated coordinator (VM1, IS_COORDINATOR=true) that pulls peer state via HTTP and runs find_placement Δeff = 1 −
0:20
Lovén et al.
Table 1. Pipeline-aggregated mean end-to-end latency (ms) for the four-broker market and the fair-processcount four-shard centralised oracle (each entry averages 3 load levels × 5 seeds). Δ is market−sharded in milliseconds (negative = market faster). Cell wins counts the per-cell market/sharded/tie outcomes (tie threshold ±1 ms; 3 load levels per pipeline). The full per-cell single-process oracle / market / sharded comparison is in Table S1. Pipeline cqi-chain (tree) anomaly-sp (SP) ran-entangled
Market mean Sharded mean 1822 1201 965
Δ Cell wins (mkt/OS/tie)
1848 −26 (1.4%) 1201 tied 971 −7 (0.7%)
3/0/0 1/2/0 1/1/1
over the merged topology; state-owners (VMs 2–4) expose /sharded-oracle/state. It carries the same broker-process count as the four-broker market and produces global-optimum decisions like the single-process oracle. Table 1 reports the pipeline-aggregated mean end-to-end latency for the four-broker market and the four-shard centralised oracle (5 seeds per cell, ∼8000–41,000 events per cell, three load levels per pipeline). The full per-cell detail (single-process oracle, four-broker market, four-shard oracle across the 9 (pipeline, load) configurations) is reported in the supplementary material as Table S1. Across the 9 (pipeline, load) cells × 5 seeds the four-broker market trades within ±1.5% of the four-shard centralised oracle on every cell: market dominates cqi-chain (3/3 cells, 1.4% mean), the sharded oracle is marginally favoured on anomaly-sp at the cell level (one market win, two sharded wins, all within ±5 ms), and ran-entangled splits one market win / one sharded win / one tie. Per-cell totals over the 9 cells are 5 market wins / 3 sharded wins / 1 tie. Self-organisation pays at most a 1.5 % coordination cost across 9 cells, dominates linear-chain by 1.4 %, and trades within ±5 ms on series-parallel and entangled DAGs. The decentralised-vs-centralised inversion observed against the single-process oracle (a ∼3% market gap with 45 of 45 per-seed wins, Table S1) therefore holds against the fair-process-count comparator on tree pipelines; on series-parallel and entangled DAGs the architectural advantage becomes pipeline-structure-conditional rather than uniform. The four-broker market is uniformly faster than the single-process centralised oracle by 2–4% in mean latency across all 9 (pipeline, load) configurations, with the market winning in every individual seed-level run (45 of 45 cells; tie threshold |𝐿¯market − 𝐿¯oracle | < 1 ms, below the within-VM clock noise floor); the per-cell detail underpinning this count is in Table S1. This inverts the classical centralised-versus-decentralised comparison at the single-broker scale: the single-process oracle becomes a contention bottleneck for state, queue depth, and dispatch decisions even at 2 pps, while the four federated market brokers distribute these costs. The fair-process-count comparator (Table 1) controls for this asymmetry: at equal broker-process count the gap stays within ±1.5% across all 9 cells. The architectural advantage becomes pipeline-structure-conditional: market dominates the linear-chain cqi-chain (3/3 cells, 1.4%), trades within ±5 ms on series-parallel anomaly-sp (1 market / 2 sharded / 0 ties; sharded is marginally favoured at +5 ms / +2 ms on the low-load and medium-load cells), and ties on entangled ran-entangled at the cell level (1/1/1). Completion-rate evidence corroborates the single-process-bottleneck explanation: at 10 pps cqi-chain, single-process oracle completion drops to 99.4% while both market and sharded oracle remain at 100.0%, the only main-grid configuration where any strategy lost completeness. Statistical anchor. A one-tailed paired sign-test on the 45-cell single-process oracle comparison gives 𝑝 = 2−45 ≈ 2.8 × 10−14 for 45 of 45 directional wins. The Hodges–Lehmann median of the 45 per-seed paired differences (market − oracle) is −39.6 ms with a percentile bootstrap 95% CI of [−44.1, −35.3] ms (𝐵 = 10,000 resamples), confirming a robust market advantage well-bounded
Oracle (centralised) Market (4 brokers)
2000 1500 1000 500 0
2\,pps
5\,pps
10\,pps
CQI chain (tree)
2\,pps
5\,pps
10\,pps
Anomaly (SP)
2\,pps
5\,pps
0:21
100 80 60 40
Oracle (centralised) Market (4 brokers) Round-robin (centralised) Calibrated knee 13.8\,pps
20 0
10\,pps
RAN suite (ent.)
(a) Near-optimality: market vs single-process oracle, all cells. 1.0
Pipeline completion rate (%)
Mean end-to-end latency (ms)
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
5
10 Arrival rate (pps)
15
(b) Round-robin CR collapse 98.8% → 22.4% → 3.3%.
RAN Intelligence Suite (entangled), 5\,pps
CQI chain (tree)
0.6 0.4
Market (4 brokers) Locality-only Latency-greedy Spillover
0.2 0.0 900
925
950
975 1000 1025 1050 1075 1100 End-to-end latency (ms)
(c) Heuristic strategy parity under uniform load.
Mean latency (ms)
CDF
0.8 Anomaly (SP)
1840
1200
1820
1180
1800 nly nly her Neit Edge o Cloud o
h
Bot
1160
nly nly her Neit Edge o Cloud o
RAN suite (ent.)
980 960 940 h
Bot
nly nly her Neit Edge o Cloud o
h
Bot
(d) Sovereignty-enforcement grid: zero runtime overhead across four scenarios.
Fig. 3. Consolidated experimental results: (a) near-optimality (market vs single-process oracle, all cells); (b) round-robin completion-rate collapse 98.8% → 22.4% → 3.3% across 𝜆 ∈ {5, 10, 15} pps; (c) heuristic strategy parity under uniform load (CDFs of mean latency for the four decentralised strategies); (d) sovereigntyenforcement grid showing zero runtime overhead across four enforcement scenarios.
away from zero. The directional signal is consistent at p50, p95, and p99 across all 9 cells: the market leads the single-process oracle at every reported percentile, with one cqi-chain-high p99 cell within run-to-run noise (Suppl. Tab. S2). Convergence and pipeline structure. The bounded staleness 𝐵 ≈ 10.05 s (Section 4.2.3) sets a price-signal-lag ceiling: up to 𝜆𝐵 ≈ 139 pipelines may arrive at one broker between exchanges; the within-round reservation ledger (Section 4.3.2) absorbs this transient locally because overallocation onto a single worker is bounded by a single pipeline’s stage count, and the next exchange resynchronises peer prices. This explains why the decentralisation inversion holds at the 𝜆 ≤ 10 pps loads we test rather than the 𝜆 > 13.8 pps regime where staleness would dominate. The pipelinestructure dimension (tree, SP, entangled) does not change the picture against the single-process oracle: the gap is uniform across all three structures. The classical prediction that entangled DAGs would widen the gap (cross-tree complementarities) is not visible. We read this finding as evidence that integrator encapsulation (Section 3.1.3) recovers a polymatroidal quotient graph for all three structures: under encapsulation the tree, SP, and entangled DAGs collapse to the same agentfacing feasibility region, and the empirical structural axis is therefore vestigial in this regime. An alternative reading, that the within-round reservation ledger suppresses over-commitment that would otherwise translate complementarities into efficiency loss, is not separately tested by the present campaign; disambiguating the two readings requires measuring the empirical non-modularity gap 𝛾 pre- and post-encapsulation and is left to future work.
0:22
5.6
Lovén et al.
Strategy Differentiation Requires Stress
Under uniform conditions in the main allocation campaign, the market and three heuristic baselines (locality-only, latency-greedy, spillover) converge to within ±5 ms of each other across every (pipeline, load) cell, and locality-only is competitive with market across all 9 cells; the per-cell detail is in Table S3, with the corresponding latency CDF in Fig. 3c. The classical centralised round-robin orchestrator is also competitive at 5 pps. The 450-run ablation programme exposes the conditions under which the market mechanism actually differentiates: Table S5 reports the conventional centralised round-robin orchestrator across three stress dimensions on cqi-chain pipelines. Saturation (Fig. 3b). The conventional round-robin orchestrator drops from CR = 98.8% at 𝜆=5 pps to 22.4% at 𝜆=10 pps to 3.3% at 𝜆=15 pps, with mean latency rising from 1.8 s to 9.6 s. The transition is sharp around the calibrated saturation knee at 𝜆≈13.8 pps. The market mechanism, by contrast, holds CR = 100% at 𝜆 ≤ 10 pps and degrades gracefully thereafter (83.3% at 𝜆=15 pps; 25.4% at 𝜆=50 pps where rr-global completes 0%). The fair-process-count sharded oracle tracks the market closely across the entire sweep: 1832 ms / 100% at sat-5, 1853 ms / 100% at sat-10, and 2105 ms / 83.8% at sat-15 (full 𝑛 = 5 seeds for sharded; market partial 𝑛 = 4 at sat-15). At the saturation regime (𝜆=15 pps) market and sharded oracle differ by 14 ms in mean latency and 0.5 percentage points in CR — both autonomic-coordinated centralised and decentralised architectures degrade gracefully and identically when the testbed crosses the calibrated knee, while rr-global collapses. The single-process oracle’s sat-15 cell is partial (𝑛 = 2) but tracks worse on CR (74.1%) than either four-broker mechanism. Table S4 reports the full saturation sweep across all four strategies. Failure × load interaction. Under worker kill at mid-measurement, rr-global’s CR depends sharply on offered load: at 5 pps it survives kill of 12 workers (96.7% CR); at 8 pps it collapses (33.5%); at 10 pps further (22.5%). The market mechanism’s clearing prices encode worker availability immediately (a dead worker has effectively infinite price), and its CR remains 100% across all scenarios. Heterogeneity. With edge workers 2× slower and cloud workers 1.5× faster, rr-global produces 2508 / 1544 / 1251 ms mean latency on cqi-chain / anomaly-sp / ran-entangled while the market produces 1290 / 851 / 702 ms — 48.6% / 44.9% / 43.9% reductions (≈ 46% mean). Round-robin bottlenecks on the slow edge tier; the market’s speed-scaled bid (Section 4.3.2) routes preferentially to fast cloud workers when they have capacity. Three-property decomposition. Each ablation scenario isolates a distinct Walrasian property absent by construction from non-autonomic baselines (Section 6.2): (i) saturation tests admission control (price-based rate limiting bounds queue length, vs unconditional round-robin dispatch); (ii) failure-times-load tests information completeness (price encodes worker availability immediately, vs the round-robin health-check loop); (iii) heterogeneity tests price discovery (scarce workers become expensive at equilibrium, vs identical treatment). These three properties are independent of GS (Theorem 3.1) and hold for any market-clearing mechanism over a polymatroidal feasibility region, jointly explaining why the market is the only decentralised strategy that survives the ablation. 5.7
Federation Robustness
The 25-cell federation phase exercises broker process kill, emulated edge–cloud network partition, and the governance, neural, and static placement variants. Across all 25 runs CR remains ≥ 98.7% (broker-kill, network-partition, neural, governance: 100%; static: 98.7%) with mean latency within 25 ms of baseline (1834 ms). The 50-cell worker-failure resilience phase reinforces this at the perstage level: across both edge sites (eMBB-kill on VM2, URLLC-kill on VM1), neural-placement (S3) worker death mid-experiment yields CR ≥ 99.9% across 36,098 events (VM1) and 36,092 (VM2).
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:23
All resilience cells run cqi-chain (a tree, no funnel structure), so the funnel-mode failure handling variants (wait/proceed/abort) are not exercised here; we mark this as a coverage limitation in Section 5.9. 5.8
Sovereignty Enforcement Adds Zero Runtime Overhead
Across all 60 governance-grid runs (4 enforcement scenarios × 3 pipeline types × 5 seeds; per-cell detail in Table S6, illustrated in Fig. 3d) the mean latency matches the corresponding non-governance baseline to within 1–3 ms, consistent with the slicing-phase governance-overhead finding (Section 5.4). Sovereignty enforcement (stages tagged local-only cannot leave the originating domain) imposes no measurable runtime cost on this scale of testbed across all four enforcement regimes (none, edge-only, cloud-only, both). This confirms that the autonomic substrate honours domainlevel data-sovereignty invariants without external orchestration cost: the polymatroidal feasibility region of Eq. (8) accepts arbitrary per-domain locality predicates as coordinate-wise upper bounds, and the broker’s marginal-cost clearing automatically routes around forbidden assignments. 5.9
Threats to Validity
Internal validity. Pipeline processing times are simulated (configurable delays calibrated to representative NWDAF workloads), not real ML inference. Semantic matching is exercised as a frozen, pre-calibrated component (Section 3.3), isolating distribution-architecture variables from matching-quality variation. Market clearing uses marginal-cost pricing, a simplification of the full ascending auction of Theorem 3.1; the gap between simplified and optimal pricing is part of the measured Δeff and works in the unexpected direction in the single-process oracle comparison (Section 5.5). External validity. The testbed uses 4 VMs with 48 workers across 4 administrative domains, connected by 1 emulated WAN link. All VMs reside in the same data centre (5GTNF, Oulu); the WAN characteristics are emulated via tc qdisc netem as a fixed 50 ms delay plus 5 ms uniform jitter. Bandwidth limits, packet loss, packet reordering, path asymmetry, and cross-traffic contention are out of scope for this campaign. The control-plane price-signal exchange is small (a few KB per peer per 𝛿 prop epoch), so bandwidth limits are not load-bearing within the tested regime; the orchestration result is conditional on loss / reorder / asymmetry / contention being below the levels at which broker-side TCP retransmission and the 𝑘 miss = 3 failover regime begin to misclassify peers as unhealthy. Cross-site validation on real WAN infrastructure (Oulu↔Tokyo, ∼150 ms RTT) is planned as future work. The three 8-stage pipeline types span the structural spectrum (tree, SP, entangled) relevant to the polymatroidal efficiency result. Coverage limitations. The funnel-mode failure-handling variants (wait, proceed, abort) defined in the architecture (Section 4.7) are not exercised by the current resilience phase, because all resilience cells use cqi-chain pipelines (a tree, no funnel structure). Funnel-pipeline experiments are scheduled for a follow-on campaign. Heterogeneous-domain regimes that would exercise multilevel governance composition theory (the subject of forthcoming companion work; asymmetric trust, capacity, or data quality across sites) are out of scope for this homogeneous-load campaign and are scheduled for follow-on work. The "edge-HPC/cloud continuum" scope advertised by the SI is exercised at the orchestration layer (four-domain federation, sovereignty enforcement, cross-site WAN emulation) but not at the infrastructural layer (single data centre, no HPC tier); see the Scope paragraph in Section 1. Construct validity. The efficiency measure 𝜂 combines pipeline completion, latency, and cost. The sovereignty-enforcement scenarios (edge-only, cloud-only) test enforcement at the site level, not the individual-domain level; the 2×2 design controls for site-level asymmetry. Docker containers share VM CPU and memory; CPU pinning mitigates resource contention between brokers. The
0:24
Lovén et al.
five engineering refinements of Section 4.3.2 are jointly sufficient for the empirical envelope tested; per-component leave-one-out attribution is deferred to follow-on work. 6 6.1
Discussion Security and Governance
Limitations. The 4-VM evaluation uses four logical domains (48 workers, four brokers); production deployments scale to hundreds of workers per domain. Theorem 3.1 is scale-independent, but Δeff may differ at larger scale. Pipeline processing times are configurable delays rather than real ML inference, by design to isolate placement / market mechanisms as independent variables. The marginal-cost pricing of Algorithm 1 approximates the polyhedral clinching auction of Theorem 3.1; the gap is part of the measured efficiency gap. The full threats-to-validity analysis is in Section 5.9. The Neural Pub/Sub broker operates in embedding space and exchanges only subscription summaries (centroid embeddings + cluster radii) and price signals, neither revealing individual subscription text or worker-level cost information; embedding-inversion risks [57] qualify this — text-embedding inversion attacks can recover fragments of source text from raw embeddings, so privacy “reduces but does not eliminate raw-content leakage”. In adversarial settings, brokers may inflate prices or deflate capacity; the current architecture assumes cooperative brokers under a single operator. Commitment-based mechanisms grounded in polyhedral clinching auctions [8, 29] (already invoked in Section S2 of the electronic supplement) and post-hoc evidence-bundle auditability are well-known directions for the multi-vendor adversarial regime; their integration is outside this paper’s scope. Sovereignty enforcement adds zero observable overhead (Section 5.8); sovereignty constraints are motivated by data-protection regulations (e.g., GDPR data residency) but the substrate accepts arbitrary per-domain locality predicates as coordinate-wise bounds on the polymatroidal feasibility region (Section 4.1). Forthcoming companion work on multi-level governance composition predicts that partial enforcement across credibility levels can be structurally counterproductive under asymmetric trust, capacity, or data quality; testing this in a heterogeneous-domain campaign is future work and lies outside the homogeneous-load regime studied here. 6.2
Deployment Gradient and Continuum Self-Management
The polymatroidal allocation framework is currency-agnostic [52], enabling a three-level deployment gradient: (i) internal priority scheduling (single domain, synthetic priority tokens, minimal governance — no real economy needed), (ii) federated priority (cross-domain, shared priority-token price signals via Section 4.3), and (iii) full service economy (real currency, commitment-based credibility stack outside this paper’s scope). Disaggregated continuum deployments (e.g., O-RAN) create precisely the multi-domain scenario the substrate addresses; the price-signal layer adds an economic-incentive layer (price-signal correctness, under-/over-reporting accounting) complementing cryptographic trust controls (mTLS / OAuth / certificate-based identity, e.g., O-RAN WG11 [63]). The market preserves operator/vendor confidentiality (each broker exposes only aggregate price signals; internal cost structures and capacity utilisation remain private), while a centralised orchestrator would require disclosing proprietary operational details, foreclosing adoption. The single-process oracle’s high-load sensitivity (Section 5.5) echoes the “reallocation storm” phenomenon [50, 51]; the price-signal feedback loop dampens it (overloaded domains become expensive and divert traffic). The three Walrasian properties of Section 5.6 (information completeness, admission control, price discovery) are independent of GS and delineate when round-robin suffices (uniform load, single visibility scope) versus when a market is required (multi-domain continuum, asymmetric capacity / failure / trust, vendor confidentiality). Production single-cluster schedulers
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:25
(Kueue [41], Volcano [81]) recover admission control via priority queues with quotas, but price discovery and federation-level information completeness presuppose multi-control-plane visibility that single-cluster schedulers do not provide. Multi-cluster federation operators (KubeFed, Karmada, Liqo) and cross-cluster cohort-borrowing extensions (Kueue MultiKueue) close the multi-controlplane gap at the orchestration layer, but on a different axis: they rely on a federated control-plane operator that has visibility into every cluster’s state, whereas Neural Pub/Sub brokers exchange only aggregate price signals and subscription summaries with bounded staleness, preserving operator confidentiality. The substrate also commits at per-pipeline timescales (one clearing decision per pipeline arrival) rather than the per-pod / per-job timescales of cluster-federation operators. Scaling ¯ federation cost to hundreds of workers per domain via hierarchical broker federation has 𝑂 (𝑚 · 𝑝) (Section 4.7); validation via EISim [39] is future work. HPC-tier integration. The Special Issue spans the edge–HPC/cloud continuum [12, 68]; the present campaign exercises the edge–cloud tiers but not a tier-1 supercomputing site. Architecturally, an HPC domain enters the substrate as a batch-queue endpoint rather than a worker pool, and the federation contract degrades gracefully to it: integrator encapsulation (Section 3.1.3) contracts the HPC sub-DAG to a single composite node whose marginal-cost bid is the queue’s expected wait, so a batch-tier domain participates in market clearing as one coarse-grained composite worker without exposing its internal scheduler. The within-round reservation ledger (Section 4.3.2), however, is calibrated to the ∼10 s bounded-staleness regime of Section 5.5: bulk-synchronous HPC queueing introduces wait-time variance at the 102 –103 s timescale, at which a within-round ledger is too coarse to track admission and a coarser commitment epoch (one clearing per batch window rather than per pipeline arrival) is required. Quantifying that regime — a Pegasus-style cross-data-centre workflow with a tier-3 site — needs an HPC testbed arm and is deferred to the follow-on systems campaign; the autonomic mechanism is HPC-tier-compatible by construction but unproven in that regime. 6.3
Assurance and Verification
The autonomic loop’s correctness rests on a stated operating envelope rather than a closed-form assurance proof: bounded staleness 𝐵 = 𝛿 prop + WANmax ≈ 10.05 s, arrival rate 𝜆 ≤ 13.8 pps for the round-robin saturation knee with 𝜆𝐵 ≤ 139 pipelines absorbed by the within-round reservation ledger, and federation peer-liveness misclassification bounded by the 𝑘 miss = 3 failover regime under the 𝛿 prop = 10 s exchange period (Sections 4.2.3 and 4.3.2). Within this envelope, the substrate’s safety invariants are: (i) no pipeline stage is dispatched to a worker with 𝜌𝑖 ≥ 0.99 (admissioncontrol guarantee from the 𝜌𝑖 cap in Eq. (14)), (ii) no within-round over-commitment exceeds a single pipeline’s stage count (reservation-ledger invariant), and (iii) sovereignty constraints are coordinate-wise upper bounds on the feasibility region and cannot be violated by any marketclearing decision (Section 4.1). Liveness rests on the eventual-consistency reading of Theorem 3.1: each broker’s local clearing converges to the equilibrium price under bounded staleness as the next federation exchange resynchronises peer prices. Statistical model-checking of these invariants under perturbation [16, 75, 82] would strengthen the assurance argument and is a natural next step; the present paper substantiates the envelope empirically through the perturbation campaign of Section 5 (failure injection, partition, saturation sweeps) rather than through formal verification. 6.4 Open Questions Three directions remain open. Broker incentive alignment: federated brokers face strategic incentives (price misreporting, capacity withholding, cross-domain favouritism) under adversarial multivendor deployments; broker accountability (commitment-based pricing, cross-broker auditing, coalition deterrence) integrated with the federation protocol is future work. Dynamic credibility and
0:26
Lovén et al.
multi-agent negotiation: governance enforcement adapting to evolving trust levels via repeated-game analysis (subject of forthcoming companion work), and broker price signals as a coordination layer beneath MAS negotiation protocols. Semantic-communication transport: semantic codecs [70, 85] beneath Neural Pub/Sub’s application-layer routing (Section 3.3) could reduce backhaul traffic while preserving application-level matching; quantifying the bandwidth saving is future work. 7
Conclusion
We presented Neural Pub/Sub, an autonomic federated-broker substrate for the edge–cloud computing continuum, in which self-organisation arises from market-based price signals rather than centralised control. The substrate closes a MAPE-K control loop at each broker over per-worker monitoring, marginal-cost clearing-price analysis, polymatroidal placement planning, federated cross-domain dispatch, and bounded-staleness shared knowledge (Section 4.4). The design is anchored in a Walrasian convergence proposition imported from companion work (Theorem 3.1, Section S2 of the electronic supplement): under gross-substitutes valuations on tree and seriesparallel service-dependency DAGs, decentralised price-based allocation matches the welfare of a centralised oracle. A 1005-run, seven-phase campaign on a 4-domain, 48-worker testbed, supplemented by a fairprocess-count sharded-oracle comparator, supports four findings. The four-broker market beats a single-process oracle by 2–4% in mean latency across all 9 (pipeline, load) cells with 45 of 45 per-seed wins (sign-test 𝑝 ≈ 2.8 × 10−14 ); against the fair-process-count four-shard centralised oracle the gap is within ±1.5% across all 9 cells, with the market dominating linear-chain cqi-chain (3/3) and ties or marginal sharded wins on series-parallel anomaly-sp and entangled ran-entangled (Section 5.5). Self-management differentiates only under stress: round-robin completion rate collapses 98.8% → 22.4% → 3.3% across 𝜆 ∈ {5, 10, 15} pps while the market preserves CR, and the advantage decomposes into three Walrasian properties (information completeness, admission control, price discovery) absent from non-autonomic baselines (Section 5.6). The federation withstands broker process kill, emulated cross-site partition, and per-stage worker death across both edge sites with CR ≥ 98.7% across 75 cells (Section 5.7). Sovereignty enforcement adds zero measurable runtime overhead across 60 governance-grid runs (four enforcement scenarios × three pipeline types × five seeds), confirming that the autonomic substrate honours domain-level data-sovereignty invariants without external orchestration cost (Section 5.8). The contributions are an autonomic federated-market substrate for the edge–cloud continuum, the empirical decentralised-vs-centralised inversion at equal process count, and a structural decomposition of when autonomic strategies differ. Future work targets heterogeneous-domain experiments designed to test multi-level governance composition theory (the subject of forthcoming companion work) under asymmetric trust, capacity, and data quality, scaling validation via EISim [39] to production-scale deployments, broker-accountability mechanisms (commitmentbased pricing, cross-broker auditing) for adversarial multi-vendor settings, and dynamic credibility adaptation. The substrate’s currency-agnostic design supports a deployment gradient from internal priority scheduling within a single domain to full service economies spanning multiple administrative domains and jurisdictions, with the same MAPE-K guarantees applying at each stage. ACKNOWLEDGMENTS This work was supported by the Research Council of Finland through the 6G Flagship programme (grant 318927), the Strategic Research Council affiliated with the Academy of Finland through the CO2CREATION project (grant 372355), by Business Finland through the Neural pub/sub research
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:27
project (diary number 8754/31/2022), and by the European Regional Development Fund (ERDF; project numbers A81568, A91867). Conflict of Interest The authors declare no competing financial or personal interests that could have appeared to influence the work reported in this paper. Code and Data Availability The broker codebase, run-driver scripts, per-cell raw CSV data, and analysis notebooks underlying the paper’s results are released at https://github.com/lloven/neural-pubsub-experiments under the Apache-2.0 license and archived at Zenodo (https://doi.org/10.5281/zenodo.20392551); see REPRODUCING.md (seven-phase campaign protocol, smoke tests, figure scripts) and CITATION.cff in the repository.
0:28
Lovén et al.
Table S1. Mean end-to-end latency (ms) for single-process oracle (Oracle1 ), four-broker market, and fourshard centralised oracle (Oracle4 ) across pipeline structure and load. Gap columns are market−named-oracle in milliseconds (negative = market faster); SE is the standard error of the M−O1 paired difference across the 5 seeds in the cell.
S1
Pipeline
Load
cqi-chain (tree) cqi-chain cqi-chain anomaly-sp (SP) anomaly-sp anomaly-sp ran-entangled ran-entangled ran-entangled
low (2 pps) medium (5 pps) high (10 pps) low medium high low medium high
Oracle1 Market Oracle4 M−O1 1852 1874 1908 1199 1237 1285 973 992 1008
1792 1824 1852 1170 1186 1246 948 958 988
1806 1838 1901 1165 1184 1253 946 959 1010
SE M−O4
−60 0.8 −50 1.7 −56 11.8 −29 0.4 −51 0.6 −39 1.9 −25 0.6 −34 0.8 −20 2.6
−14 −14 −49 +5 +2 −7 +2 −1 −22
Overview
This electronic supplement collects the per-cell detail tables supporting the four headline findings of the main paper, whose body presents only the aggregated results; the detail here supports reviewers seeking finer-grained traceability. The supplement’s own tables carry an S prefix (Tab. S1, etc.) to distinguish them from the main paper’s. S1.1
Per-Cell Detail: Single-Process Oracle, Market, and Sharded Oracle
Table S1 reports the full 9-cell comparison underpinning the main paper’s aggregated nearoptimality table: mean end-to-end latency for the single-process centralised oracle (Oracle1 ), the four-broker market, and the four-shard centralised oracle (Oracle4 , designated coordinator at VM1, peer state pulled via HTTP, global-optimum decisions over the merged topology) across the 9 (pipeline, load) configurations of the main market campaign (5 seeds each, ∼8000–41,000 events per cell). The market beats the single-process oracle in every cell (45/45 per-seed wins). Against the fair-process-count sharded oracle the gap is within ±1.5% across all 9 cells. Table S2 reports tail-latency percentiles (p50, p95, p99) for the four-broker market and the singleprocess oracle on the same 9 (pipeline, load) cells (events pooled across 5 seeds; success-only). Market dominates at every percentile on cqi-chain (low / medium) and on every anomaly-sp and ran-entangled cell; on cqi-chain high the p99 difference is within +23 ms and within run-to-run noise (the 99th-percentile estimate fluctuates by ±30 ms across seeds at ∼40,000 events per cell). The directional signal of Table S1 is consistent at p50 / p95 / p99 with the mean-latency comparison. S1.2
Per-Cell Detail: Heuristic Strategies and Round-Robin Stress
Under uniform conditions in the main allocation campaign, the market and three heuristic baselines (locality-only, latency-greedy, spillover) converge to within ±5 ms of each other across every cell (Table S3); locality-only is competitive with market across all 9 cells. The 450-run ablation programme exposes the conditions under which the market mechanism actually differentiates. Table S5 reports the conventional centralised round-robin orchestrator across three stress dimensions on cqi-chain pipelines.
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:29
Table S2. Tail-latency percentiles (ms) for the single-process oracle (Oracle1 ) and four-broker market across the 9 (pipeline, load) cells. Events are pooled across 5 seeds (success-only). Oracle1 Pipeline
Load
p50
p95
Market p99
p50
p95
p99
cqi-chain low 1841 1933 1989 1787 1829 1878 cqi-chain medium 1856 2012 2102 1814 1904 2004 cqi-chain high 1859 2107 2211 1816 2070 2234 anomaly-sp low 1191 1256 1320 1168 1191 1235 anomaly-sp medium 1224 1339 1433 1181 1228 1306 anomaly-sp high 1257 1487 1643 1223 1411 1621 ran-entangled low 970 1003 1055 947 962 980 ran-entangled medium 984 1060 1149 955 985 1052 ran-entangled high 990 1137 1276 974 1081 1262 Table S3. Mean latency (ms) across decentralised strategies under uniform conditions; all four converge. Pipeline
Load
Market
Locality
Lat-greedy
Spillover
cqi-chain cqi-chain cqi-chain anomaly-sp anomaly-sp anomaly-sp ran-entangled ran-entangled ran-entangled
low med high low med high low med high
1792 1824 1852 1170 1186 1246 948 958 988
1791 1819 1845 1170 1189 1240 950 963 995
1797 1828 1849 1174 1192 1248 949 962 993
1794 1825 1846 1173 1190 1240 949 961 992
Table S4. Saturation sweep across all four placement strategies on cqi-chain (5 seeds per cell except where indicated). The four-broker market and the four-shard centralised oracle remain within ±15 ms across every load and report identical completion rates within 0.5 percentage points; rr-global collapses dramatically at 𝜆 ≥ 10 pps. The single-process oracle’s sat-15 cell is partial (n=2 from an earlier campaign); market-quad sat-15 is n=4.
Strategy
sat-5 (5 pps) CR% mean ms
sat-10 (10 pps) CR% mean ms
oracle (single-process) market (4-broker) oracle (4-shard) rr-global
100.0 100.0 100.0 95.5
100.0 100.0 100.0 19.9
1872 1845 1832 1999
1888 1845 1853 4803
sat-15 (15 pps): saturation regime oracle (single-process) market (4-broker) oracle (4-shard) rr-global
S1.3
74.1% / 2331 ms (n=2) 83.3% / 2091 ms (n=4) 83.8% / 2105 ms 3.3% / 10981 ms
Per-Cell Sovereignty-Enforcement Grid
Table S6 reports mean latency for the four sovereignty-enforcement scenarios (none, edge-only, cloud-only, both) across three pipeline types at medium load (5 seeds each, 5×3×4 = 60 runs). All
0:30
Lovén et al.
Table S5. Conventional round-robin orchestrator across three stress dimensions, on cqi-chain pipelines. The market preserves CR = 100% at every load tested up to 𝜆=10 pps and degrades gracefully thereafter (CR = 25.4% at 𝜆=50 pps where rr-global is 0%). Stress dimension
Scenario
Description
rr-global CR%
rr-global mean (ms)
Saturation (no failure)
sat-5 sat-10 sat-15
𝜆=5 pps, no failure 𝜆=10 pps, no failure 𝜆=15 pps, no failure
98.8 22.4 3.3
1843 3395 9598
Failure × load
failure-5-12 failure-8-12 failure-10-12
𝜆=5 pps, kill 12 workers 𝜆=8 pps, kill 12 workers 𝜆=10 pps, kill 12 workers
96.7 33.5 22.5
1940 3262 3708
Heterogeneity
het
2× slow edge / 1.5× fast cloud workers
94.3
2508
Table S6. Sovereignty-enforcement grid: mean latency (ms) across four enforcement scenarios. All scenarios are within ±3 ms of each other across every pipeline. Pipeline
none
edge-only
cloud-only
both
cqi-chain anomaly-sp ran-entangled
1824 1188 959
1825 1188 960
1826 1191 960
1826 1190 960
four scenarios are within ±3 ms of each other across every pipeline, demonstrating zero measurable runtime overhead from sovereignty enforcement (Finding 4 of the main paper). S2
Self-Contained Statement of Proposition 3.1
This section of the electronic supplement restates the Walrasian convergence proposition on which the main paper’s market mechanism is grounded, with conditions stated formally and a pointer to where the proof lives in companion work [52]. The proposition is imported as a black box: its proof is not reproduced here, but the conditions under which it holds are made explicit so that a reviewer can verify whether the conditions are met by the deployment of the main paper’s distribution architecture (§4). Cross-references of the form “§4” or “Eq. (3)” point into the main paper; this supplement compiles standalone. Setting. Let 𝐺 res = (R, 𝐸) be a service-dependency DAG with capacities {𝐶 𝑣 } 𝑣 ∈ R and leaf services 𝐿(𝐺) ⊆ R, defining the service-feasibility region Xres of the main paper (Eq. (3)). Let X𝑡 = Xres ∩ Xgov be the governance-constrained feasibility region (main paper, Eq. (8)). Conditions. (1) Laminar structure. The constraint family {𝐿𝑣 : 𝑣 ∈ R \ 𝐿(𝐺)} is laminar on 𝐿(𝐺): for any two members 𝐿𝑣 , 𝐿𝑣 ′ , either 𝐿𝑣 ⊆ 𝐿𝑣 ′ , 𝐿𝑣 ′ ⊆ 𝐿𝑣 , or 𝐿𝑣 ∩ 𝐿𝑣 ′ = ∅. This holds in particular when 𝐺 res is a rooted tree or a two-terminal series-parallel network (see the main paper’s §3.1 for the parse-tree structural argument). (2) Polymatroidal feasibility. Under condition (1), Xres is a polymatroid with rank function 𝑓 defined by Eq. (4) of the main paper [24, 28]. Coordinate-wise governance bounds preserve polymatroidal structure; therefore X𝑡 is also polymatroidal. (3) Gross-substitutes valuations. Each agent’s valuation over leaf-allocation slices satisfies the gross-substitutes (GS) condition of [35]. This condition is non-trivial: pipeline-bundle valuations are perfect-complements (Leontief) on the raw stage set, and the GS-compatible
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:31
representation arises only after integrator encapsulation [52], where each domain’s broker bundles its multi-resource sub-DAG into a single composite slice with unit demand at the agent-facing level (main paper, §3.1.3 and §4.2.4). Buyer-side GS sketch. The agent’s raw valuation over the eight stage types is Leontief: 𝑣 raw (𝑥) = 𝑣 ★ · 1[𝑥 ≥ 1𝑉 ] on {0, 1}𝑉 , which is not GS. After integrator encapsulation each domain’s broker contracts its sub-DAG into a composite item; the buyer-facing item set becomes the set of traversed domains D and the valuation 𝑣 (𝑥) = 𝑣 ★ · 1[𝑥 ≥ 1𝐷 ] is unit-demand-per-domain on the integrator quotient. Unit-demand satisfies GS [35], so the buyer-facing layer is GS by construction and the non-modularity gap 𝛾 of the main paper’s §5.1 is 𝛾 = 0 post-quotient. “Residual encapsulation losslessness” (the integrator’s max-flow, main paper Eq. (10), is achieved without an internal subDAG bottleneck, so the composite item’s unit demand is realisable) is the load-bearing assumption deferred to [52]. Statement and where the proof lives. Under Í conditions (1)–(3): (a) a Walrasian equilibrium (𝒑 ∗, 𝒙 ∗ ) exists; (b) 𝒙 ∗ maximises social welfare 𝑖 𝑣𝑖 (𝑥𝑖∗ ); (c) (𝒑 ∗, 𝒙 ∗ ) is computable in polynomial time by an ascending polyhedral-clinching auction [8, 29] on the polymatroidal region X𝑡 . Conditions (1)–(2) are classical [24, 28]; (a)–(b) follow from Kelso–Crawford [35] and Gul–Stacchetti [32] given the polymatroidal structure; the AI-pipeline construction and the integrator-encapsulation reduction are in [52]; (c) follows from [8, 29]. Implementation gap. Algorithm 1 of the main paper implements marginal-cost clearing (main paper, Eqs. (14) and (11)), not the full polyhedral-clinching auction of (c) (cf. the main paper’s §4.3.2 five-component refinement); the empirical efficiency gap of the main paper’s §5.5 therefore characterises the distance between marginal-cost clearing and the welfare-maximising equilibrium of Proposition 3.1, not the equilibrium itself. Deployment laminarity check. The parse-tree argument of the main paper (§3.1.2) certifies that all three deployment pipelines satisfy condition (1): cqi-chain is a rooted tree, anomaly-sp is two-terminal series-parallel (parallel detector branch composed with a fusion stage at the nearRT RIC), and ran-entangled becomes laminar after integrator encapsulation [52] contracts each domain’s sub-DAG to a composite node (main paper, Eq. (5)), yielding a 4-node tree quotient; conditions (2)–(3) then follow. References [1] 3GPP. 2024. 3GPP TS 23.288: Architecture enhancements for 5G System (5GS) to support network data analytics services. Technical Report TS 23.288 V18.6.0. 3rd Generation Partnership Project. Release 18. [2] 3GPP. 2024. 3GPP TS 28.541: Management and orchestration; 5G Network Resource Model (NRM); Stage 2 and stage 3. Technical Report TS 28.541 V18.7.0. 3rd Generation Partnership Project. Release 18. [3] 3GPP. 2024. 5G; Architecture enhancements for 5G System (5GS) to support network data analytics services (3GPP TS 23.288). Technical Specification, Release 18. Accessed 2026-05-04. [4] 3GPP. 2024. 5G; Procedures for the 5G System (5GS) (3GPP TS 23.502). Technical Specification, Release 18. [5] 3GPP. 2024. 5G; System architecture for the 5G System (5GS) (3GPP TS 23.501). Technical Specification, Release 18. [6] 3GPP. 2024. Management and orchestration; Concepts, use cases and requirements (3GPP TS 28.530). Technical Specification, Release 18. [7] Anthropic. 2024. Model Context Protocol (MCP). https://modelcontextprotocol.io. [8] Lawrence M Ausubel. 2004. An efficient ascending-bid auction for multiple objects. American Economic Review 94, 5 (2004), 1452–1475. [9] Yadu Babuji, Anna Woodard, Zhuozhao Li, Daniel S. Katz, Ben Clifford, Rohan Kumar, Lukasz Lacinski, Ryan Chard, Justin M. Wozniak, Ian Foster, Michael Wilde, and Kyle Chard. 2019. Parsl: pervasive parallel programming in Python. In Proceedings of the 28th International Symposium on High-Performance Parallel and Distributed Computing (HPDC). 25–36. [10] Peter Bailis, Shivaram Venkataraman, Michael J. Franklin, Joseph M. Hellerstein, and Ion Stoica. 2014. Quantifying eventual consistency with PBS. In Communications of the ACM, Vol. 57. 93–102.
0:32
Lovén et al.
[11] Md. Faizul Bari, Shihabur Rahman Chowdhury, Reaz Ahmed, Raouf Boutaba, and Otto Carlos M. B. Duarte. 2016. Orchestrating virtualized network functions. IEEE Transactions on Network and Service Management 13, 4 (2016), 725–739. [12] Pete Beckman, Jack Dongarra, Nicola Ferrier, Geoffrey Fox, Terry Moore, Dan Reed, and Micah Beck. 2020. Harnessing the computing continuum for programming our world. Fog Computing: Theory and Practice (2020), 215–230. [13] BerriAI. 2024. LiteLLM: Call All LLM APIs Using the OpenAI Format. Accessed 2026-05-04. https://docs.litellm.ai/ docs/routing. [14] Ekaba Bisong. 2019. Kubeflow and Kubeflow Pipelines. Apress, 671–685. [15] Eirina Bourtsoulatze, David Burth Kurka, and Deniz Gündüz. 2019. Deep joint source-channel coding for wireless image transmission. In IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP). IEEE, 4514–4518. [16] Radu Calinescu, Carlo Ghezzi, Marta Kwiatkowska, and Raffaela Mirandola. 2012. Self-adaptive software needs quantitative verification at runtime. Commun. ACM 55, 9 (2012), 69–77. [17] Paris Carbone, Stephan Ewen, Gyula Fóra, Seif Haridi, Stefan Richter, and Kostas Tzoumas. 2017. State management in Apache Flink: Consistent stateful distributed stream processing. Proceedings of the VLDB Endowment 10, 12 (2017), 1718–1729. [18] Antonio Carzaniga and et al. 2001. Design and evaluation of a wide-area event notification service. ACM Transactions on Computer Systems (TOCS) 19, 3 (2001), 332–383. [19] Betty H. C. Cheng, Rogério de Lemos, Holger Giese, Paola Inverardi, Jeff Magee, Jesper Andersson, Basil Becker, Nelly Bencomo, Yuriy Brun, Bojan Cukic, et al. 2009. Software Engineering for Self-Adaptive Systems: A Research Roadmap. In Software Engineering for Self-Adaptive Systems. Lecture Notes in Computer Science, Vol. 5525. Springer, 1–26. [20] CrewAI. 2024. CrewAI: Framework for orchestrating role-playing autonomous AI agents. https://www.crewai.com. [21] Jeffrey Dean and Sanjay Ghemawat. 2008. MapReduce: Simplified data processing on large clusters. Commun. ACM 51, 1 (2008), 107–113. [22] Ewa Deelman, Karan Vahi, Gideon Juve, Mats Rynge, Scott Callaghan, Philip J. Maechling, Rajiv Mayani, Weiwei Chen, Rafael Ferreira da Silva, Miron Livny, and Kent Wenger. 2015. Pegasus, a workflow management system for science automation. Future Generation Computer Systems 46 (2015), 17–35. [23] R. J. Duffin. 1965. Topology of series-parallel networks. J. Math. Anal. Appl. 10, 2 (1965), 303–318. [24] Jack Edmonds. 1970. Submodular functions, matroids, and certain polyhedra. In Combinatorial Structures and their Applications (Proc. Calgary Internat. Conf., 1969). Gordon and Breach, 69–87. [25] ETSI. 2014. Network Functions Virtualisation (NFV); Management and Orchestration (GS NFV-MAN 001). Group Specification. [26] ETSI. 2019. Zero-touch network and Service Management (ZSM); Reference Architecture (GS ZSM 002). Group Specification. [27] Patrick Th Eugster and et al. 2003. The many faces of publish/subscribe. ACM computing surveys (CSUR) 35, 2 (2003), 114–131. [28] Satoru Fujishige. 2005. Submodular Functions and Optimization (2 ed.). Elsevier. [29] Gagan Goel, Vahab Mirrokni, and Renato Paes Leme. 2015. Polyhedral clinching auctions and the adwords polytope. J. ACM 62, 3 (2015), 1–27. [30] Google. 2025. Agent2Agent (A2A) Protocol. https://a2a-protocol.org. [31] R. L. Graham. 1966. Bounds for certain multiprocessing anomalies. Bell System Technical Journal 45, 9 (1966), 1563–1581. [32] Faruk Gul and Ennio Stacchetti. 1999. Walrasian equilibrium with gross substitutes. Journal of Economic Theory 87, 1 (1999), 95–124. [33] Taicheng Guo, Xiuying Chen, Yaqi Wang, Ruidi Chang, Shichao Pei, Nitesh V Chawla, Olaf Wiest, and Xiangliang Zhang. 2024. Large language model based multi-agents: A survey of progress and challenges. arXiv preprint arXiv:2402.01680 (2024). [34] IBM. 2006. An Architectural Blueprint for Autonomic Computing. IBM White Paper. https://www-03.ibm.com/ autonomic/pdfs/AC%20Blueprint%20White%20Paper%20V7.pdf. [35] Alexander S Kelso and Vincent P Crawford. 1982. Job matching, coalition formation, and gross substitutes. Econometrica 50, 6 (1982), 1483–1504. [36] Jeffrey O. Kephart and David M. Chess. 2003. The Vision of Autonomic Computing. Computer 36, 1 (2003), 41–50. doi:10.1109/MC.2003.1160055 [37] Changhoon Kim, Anirudh Sivaraman, Naga Katta, Antonin Bas, Advait Dixit, and Lawrence J. Wobker. 2015. In-band Network Telemetry via Programmable Dataplanes. In ACM SIGCOMM Demo. [38] Hyunjoo Kim and Manish Parashar. 2011. CometCloud: an autonomic cloud engine. In Cloud Computing: Principles and Paradigms. Wiley, 275–297.
Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum
0:33
[39] Henna Kokkonen, Susanna Pirttikangas, and Lauri Lovén. 2023. EISim: A Platform for Simulating Intelligent Edge Orchestration Solutions. In Proc. IEEE/ACM Symposium on Edge Computing (SEC), Poster Session. 1–2. Open-source: https://github.com/hennas/EISim. [40] KServe Contributors. 2024. KServe: Highly scalable and standards based model inference platform on Kubernetes. https://kserve.github.io/website/. Accessed 2026-05-04. [41] Kubernetes SIG Scheduling. 2024. Kueue: Kubernetes-native Job Queueing. https://kueue.sigs.k8s.io/. Accessed 2026-05-04. [42] Yu-Kwong Kwok and Ishfaq Ahmad. 1999. Static scheduling algorithms for allocating directed task graphs to multiprocessors. Comput. Surveys 31, 4 (1999), 406–471. [43] LangChain. 2024. LangGraph: Agent Runtime and Orchestration Framework. Accessed 2026-05-04. https://www. langchain.com/langgraph. [44] Benny Lehmann, Daniel Lehmann, and Noam Nisan. 2006. Combinatorial auctions with decreasing marginal utilities. Games and Economic Behavior 55, 2 (2006), 270–296. [45] Khaled B. Letaief, Yuanming Shi, Jianmin Lu, and Jianhua Lu. 2022. Edge Artificial Intelligence for 6G: Vision, Enabling Technologies, and Applications. IEEE Journal on Selected Areas in Communications 40, 1 (2022), 5–36. doi:10.1109/JSAC.2021.3126076 [46] Linux Foundation Networking. 2024. ONAP Architecture Overview (Open Network Automation Platform). https: //www.onap.org/. Accessed 2026-05-04. [47] Xi Liu, Jun Liu, Hong Wu, and Jing Dong. 2024. A family of truthful mechanisms for resource allocation with multiattribute demand in mobile edge computing. Cluster Computing 27 (2024), 11595–11610. doi:10.1007/s10586-024-04552-x [48] Lauri Lovén and et al. 2023. How can ai be distributed in the computing continuum? introducing the neural pub/sub paradigm. arXiv preprint arXiv:2309.02058 (2023). [49] Lauri Lovén, Abhishek Kumar, Alexander Engelhardt, Alaa Saleh, Roberto Morabito, Xiaoli Liu, Naser Hossein Motlagh, and Sasu Tarkoma. 2026. Neural Router: Semantic Content Matching for Agentic AI. arXiv preprint arXiv:2605.25701 (2026). [50] Lauri Lovén, Ella Peltonen, Erkki Harjula, and Susanna Pirttikangas. 2021. Weathering the Reallocation Storm: Large-Scale Analysis of Edge Server Workload. In 2021 Joint European Conference on Networks and Communications & 6G Summit (EuCNC/6G Summit). IEEE, 317–322. doi:10.1109/EuCNC/6GSummit51104.2021.9482593 [51] Lauri Lovén, Ella Peltonen, Leena Ruha, Erkki Harjula, and Susanna Pirttikangas. 2022. A dark and stormy night: Reallocation storms in edge computing. EURASIP Journal on Wireless Communications and Networking 2022, 1 (2022), 86. doi:10.1186/s13638-022-02170-y [52] Lauri Lovén, Alaa Saleh, Reza Farahani, Ilir Murturi, Miguel Bordallo López, Praveen Kumar Donta, and Schahram Dustdar. 2026. Real-Time AI Service Economy: A Framework for Agentic Computing Across the Continuum. arXiv preprint arXiv:2603.05614 (2026). [53] Haoxiang Luo, Yinqiu Liu, Ruichen Zhang, Jiacheng Wang, Gang Sun, Dusit Niyato, Hongfang Yu, Zehui Xiong, Xianbin Wang, and Xuemin Shen. 2025. Toward edge general intelligence with multiple-large language model (Multi-LLM): Architecture, trust, and orchestration. arXiv preprint arXiv:2507.00672 (2025). [54] Dimitrios Michael Manias, Ali Chouman, and Abdallah Shami. 2024. Semantic routing for enhanced performance of LLM-assisted intent-based 5G core network management and orchestration. In IEEE Global Communications Conference (GLOBECOM). IEEE, 1–6. [55] Paul Milgrom and John Roberts. 1990. Rationalizability, learning, and equilibrium in games with strategic complementarities. Econometrica 58, 6 (1990), 1255–1277. [56] Philipp Moritz, Robert Nishihara, Stephanie Wang, Alexey Tumanov, Richard Liaw, Eric Liang, Melih Elibol, Zongheng Yang, William Paul, Michael I Jordan, and Ion Stoica. 2018. Ray: A distributed framework for emerging AI applications. In USENIX Symposium on Operating Systems Design and Implementation (OSDI). 561–577. [57] John X. Morris, Volodymyr Kuleshov, Vitaly Shmatikov, and Alexander M. Rush. 2023. Text Embeddings Reveal (Almost) As Much As Text. In Proc. EMNLP. [58] Noam Nisan and Ilya Segal. 2006. The communication requirements of efficient allocations and supporting prices. Journal of Economic Theory 129, 1 (2006), 192–224. [59] Not Diamond. 2024. Not Diamond: Intelligent AI Model Routing. Accessed 2026-05-04. https://docs.notdiamond.ai/ docs/what-is-model-routing. [60] NVIDIA. 2024. NVIDIA Triton Inference Server. https://developer.nvidia.com/triton-inference-server. Accessed 2026-05-04. [61] O-RAN Alliance. 2024. O-RAN Architecture Description (O-RAN.WG1.OAD). Technical Specification, R003. Accessed 2026-05-04. [62] O-RAN Alliance. 2024. O-RAN Non-RT RIC Architecture (O-RAN.WG2.Non-RT-RIC-ARCH). Technical Specification. Accessed 2026-05-04.
0:34
Lovén et al.
[63] O-RAN Alliance. 2024. O-RAN Security Requirements and Controls Specification (O-RAN.WG11.SecurityRequirements-Spec). Technical Specification. Accessed 2026-05-04. [64] Isaac Ong, Amjad Almahairi, Vincent Wu, Wei-Lin Chiang, Tianhao Wu, Joseph E. Gonzalez, M. Waleed Kadous, and Ion Stoica. 2024. RouteLLM: Learning to Route LLMs with Preference Data. arXiv preprint arXiv:2406.18665. [65] OpenAI. 2025. OpenAI Agents SDK. https://github.com/openai/openai-agents-python. [66] OpenRouter. 2025. OpenRouter: Unified API for AI Models with Intelligent Provider Routing. Accessed 2026-05-04. https://openrouter.ai/docs/guides/routing/provider-selection. [67] P4 Language Consortium. 2023. P4Runtime Specification. https://p4.org/p4-spec/p4runtime/main/P4Runtime-Spec. html. Accessed 2026-05-04. [68] Manish Parashar. 2025. Everywhere and Nowhere: Envisioning a Computing Continuum for Science. Computing in Science & Engineering 27, 1 (2025), 51–56. doi:10.1109/MCSE.2025.3543924 [69] Esa Piri, Pekka Ruuska, Teemu Kanstrén, Jukka Mäkelä, Jari Korva, Atso Hekkala, Ari Pouttu, Olli Liinamaa, Matti Latvaaho, Kari Vierimaa, and Harri Valasma. 2016. 5GTN: A test network for 5G application development and testing. In 2016 European Conference on Networks and Communications (EuCNC). IEEE, 313–318. doi:10.1109/EuCNC.2016.7561054 [70] Zhijin Qin, Xiaoming Tao, Jianhua Lu, Wen Tong, and Geoffrey Ye Li. 2022. Semantic communications: Principles and challenges. arXiv preprint arXiv:2201.01389 (2022). [71] Alaa Saleh, Roberto Morabito, Schahram Dustdar, Sasu Tarkoma, Susanna Pirttikangas, and Lauri Lovén. 2025. Towards Message Brokers for Generative AI: Survey, Challenges, and Opportunities. Comput. Surveys 58, 1 (2025), 1–37. doi:10.1145/3742891 [72] Alaa Saleh, Sasu Tarkoma, Anders Lindgren, Praveen Kumar Donta, Schahram Dustdar, Susanna Pirttikangas, and Lauri Lovén. 2025. Memindex: Agentic event-based distributed memory management for multi-agent systems. ACM Transactions on Autonomous and Adaptive Systems (2025). doi:10.1145/3774946 [73] Mazeiar Salehie and Ladan Tahvildari. 2009. Self-Adaptive Software: Landscape and Research Challenges. ACM Transactions on Autonomous and Adaptive Systems (TAAS) 4, 2 (2009), 1–42. doi:10.1145/1516533.1516538 [74] Emilio Calvanese Strinati and Sergio Barbarossa. 2021. 6G Networks: Beyond Shannon Towards Semantic and Goal-Oriented Communications. Computer Networks 190 (2021), 107930. doi:10.1016/j.comnet.2021.107930 [75] Gabriel Tamura, Norha M. Villegas, Hausi A. Müller, João Pedro Sousa, Basil Becker, Gabor Karsai, Serge Mankovskii, Mauro Pezzè, Bradley Schmerl, Ladan Tahvildari, and Kenny Wong. 2013. Towards practical runtime verification and validation of self-adaptive software systems. In Software Engineering for Self-Adaptive Systems II (LNCS 7475). Springer, 108–132. [76] Sasu Tarkoma. 2012. Publish/subscribe systems: design and principles. John Wiley & Sons. [77] Sasu Tarkoma, Roberto Morabito, and Jaakko Sauvola. 2023. AI-native Interconnect Framework for Integration of Large Language Model Technologies in 6G Systems. arXiv preprint arXiv:2311.05842 (2023). [78] Haluk Topcuoglu, Salim Hariri, and Min-You Wu. 2002. Performance-effective and low-complexity task scheduling for heterogeneous computing. IEEE Transactions on Parallel and Distributed Systems 13, 3 (2002), 260–274. [79] Donald M Topkis. 1998. Supermodularity and Complementarity. Princeton University Press. [80] Jacobo Valdes, Robert E. Tarjan, and Eugene L. Lawler. 1982. The recognition of series parallel digraphs. SIAM J. Comput. 11, 2 (1982), 298–313. [81] Volcano Authors. 2024. Volcano: Cloud Native Batch System. https://volcano.sh/. Accessed 2026-05-04. [82] Danny Weyns. 2020. An Introduction to Self-Adaptive Systems: A Contemporary Software Engineering Perspective. Wiley-IEEE Press. [83] Michael Wilde, Mihael Hategan, Justin M. Wozniak, Ben Clifford, Daniel S. Katz, and Ian Foster. 2011. Swift: A language for distributed parallel scripting. Parallel Comput. 37, 9 (2011), 633–652. [84] Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, et al. 2023. AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation. arXiv preprint arXiv:2308.08155 (2023). [85] Huiqiang Xie, Zhijin Qin, Geoffrey Ye Li, and Biing-Hwang Juang. 2021. Deep learning enabled semantic communication systems. IEEE Transactions on Signal Processing 69 (2021), 2663–2675. [86] Ying Xiong, Yulin Sun, Li Xing, and Ying Huang. 2018. Extend cloud to edge with KubeEdge. In IEEE/ACM Symposium on Edge Computing (SEC). 373–377. See also https://kubeedge.io. [87] Matei Zaharia, Andrew Chen, Aaron Davidson, Ali Ghodsi, Sue Ann Hong, Andy Konwinski, Siddharth Murching, Tomas Nykodym, Paul Ogilvie, Mani Parkhe, Fen Xie, and Corey Zumar. 2018. Accelerating the Machine Learning Lifecycle with MLflow. IEEE Data Engineering Bulletin 41, 4 (2018), 39–45. [88] Milin Zhang, Mohammad Abdi, Venkat R. Dasari, and Francesco Restuccia. 2024. Semantic edge computing and semantic communications in 6G networks: A unifying survey and research challenges. arXiv preprint arXiv:2411.18199 (2024).