Paper deep dive

Autonomic Federated-Market Orchestration for the Edge-Cloud Continuum

Lauri Lovén, Roberto Morabito, Abhishek Kumar, Susanna Pirttikangas, Jukka Riekki, Sasu Tarkoma

Year: 2026Venue: arXiv preprintArea: cs.DCType: PreprintEmbeddings: 134

Intelligence

Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 90%

Last extracted: 7/8/2026, 9:07:43 PM

Summary

The paper introduces Neural Pub/Sub, a federated-broker autonomic substrate for orchestrating workloads across the edge-cloud continuum. It replaces centralized control with market-based price signals and a MAPE-K control loop, leveraging Walrasian convergence theory to ensure decentralized allocation matches centralized welfare. Evaluated on a 4-domain testbed, the system demonstrates superior completion rates under saturation, robustness to failures, and zero-overhead sovereignty enforcement, outperforming traditional round-robin schedulers and matching sharded centralized oracles.

Entities (16)

Neural Pub/Sub · system · 98%Edge-Cloud Continuum · paradigm · 97%MAPE-K · framework · 96%Federated Brokers · component · 95%Walrasian Equilibrium · concept · 94%Data Sovereignty · constraint · 93%University of Oulu · institution · 92%Polymatroidal Feasibility Region · concept · 91%EURECOM · institution · 90%5GTNF Testbed · infrastructure · 89%Round-Robin · baseline · 88%Sharded Oracle · baseline · 87%Service-Dependency DAGs · data-structure · 86%Clearing-Price Analysis · process · 85%Cross-Domain Dispatch · process · 84%Completion Rate · metric · 83%

Relation Signals (14)

Neural Pub/Sub → targets → Edge-Cloud Continuum

confidence 96% · The edge-cloud computing continuum demands self-management mechanisms that scale across autonomous administrative domains while honouring tenant- and operator-specified data sovereignty.

Neural Pub/Sub → implements → MAPE-K

confidence 95% · The substrate’s autonomic behaviour closes a MAPE-K control loop over per-broker health monitoring, marginal-cost clearing-price analysis, polymatroidal placement planning, federated dispatch execution, and peer subscription summaries.

Neural Pub/Sub → uses → Federated Brokers

confidence 94% · We present Neural Pub/Sub, a federated-broker autonomic substrate whose self-organising behaviour emerges from market-based price signals rather than centralised control.

Neural Pub/Sub → enforces → Data Sovereignty

confidence 93% · The substrate enforces tenant- and operator-specified data sovereignty (which stage types may leave their originating domain) as a coordinate-wise constraint on the feasibility region.

Neural Pub/Sub → relieson → Walrasian Equilibrium

confidence 92% · 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.

Neural Pub/Sub → outperforms → Round-Robin

confidence 91% · Round-robin completion rate collapses 98.8% -> 22.4% -> 3.3% across arrival rates 5/10/15 pps while the market preserves completion

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:The edge-cloud computing continuum demands self-management mechanisms that scale across autonomous administrative domains while honouring tenant- and operator-specified data sovereignty. We present Neural Pub/Sub, a federated-broker autonomic substrate whose self-organising behaviour emerges from market-based price signals rather than centralised control. Its MAPE-K control loop closes over per-broker health and load monitoring, marginal-cost clearing-price analysis, placement planning over a polymatroidal feasibility region, federated cross-domain dispatch, and shared peer subscription summaries with bounded-staleness 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. We evaluate the substrate on a 4-VM, 4-domain, 48-worker federated edge-cloud testbed (single data centre, 50 ms emulated WAN) in a 1005-run campaign augmented by a fair-process-count sharded-oracle comparator. The federated market dominates a single-process oracle by 2-4% with 45 of 45 per-seed wins (sign-test p ~ 2.8e-14, Hodges-Lehmann median -39.6 ms); against a four-shard centralised orchestrator at equal process count the gap stays within +/-1.5% across all nine (pipeline, load) cells. Round-robin completion rate collapses 98.8% -> 22.4% -> 3.3% across arrival rates 5/10/15 pps while the market preserves completion; the advantage decomposes into three Walrasian properties (information completeness, admission control, price discovery). Federation withstands broker death and network partition (completion rate >= 98.7% across 75 cells), and sovereignty enforcement adds no measurable runtime overhead across 60 governance-grid runs. Heterogeneous-domain stressors and cross-site WAN deployment remain future work.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

133,435 characters extracted from source content.

Expand or collapse full text

Autonomic Federated-Market Orchestration for the Edge–Cloud Continuum Lauri Lovén 0000-0001-9475-4839 Future Computing Group, University of OuluOuluFinland lauri.loven@oulu.fi , Roberto Morabito EURECOMSofia AntipolisFrance , Abhishek Kumar University of JyväskyläJyväskyläFinland , Susanna Pirttikangas AMD Silo AIOuluFinland , Jukka Riekki Future Computing Group, University of OuluOuluFinland and Sasu Tarkoma University of Oulu and University of HelsinkiOulu / HelsinkiFinland Abstract. 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 federated-broker 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%± 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%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%≥ 98.7\%), and sovereignty enforcement adds no measurable runtime overhead. Autonomic computing, edge–cloud continuum, self-organisation, market-based allocation, federated brokers, MAPE-K, sovereignty enforcement, Walrasian equilibrium, polymatroidal feasibility †copyright: none†journal: TAAS†journalyear: 2026†journalvolume: 0†journalnumber: 0†article: 0†ccs: Computer systems organization Self-organizing autonomic computing†ccs: Computer systems organization Distributed architectures†ccs: Computing methodologies Multi-agent systems†ccs: Theory of computation Algorithmic mechanism design 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 (Parashar, 2025). 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 (Kephart and Chess, 2003; IBM, 2006) 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. 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. Figure 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). 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 (Kephart and Chess, 2003; IBM, 2006) (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 (Xiong et al., 2018)) and batch schedulers (Kueue (Kubernetes SIG Scheduling, 2024), Volcano (Volcano Authors, 2024)) 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 (Carbone et al., 2017), Ray (Moritz et al., 2018)) move data at scale but route by topic partitions, not by semantic content of service requests. ML pipeline orchestrators (Kubeflow (Bisong, 2019), Argo Workflows, MLflow (Zaharia et al., 2018)) 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 (Salehie and Tahvildari, 2009; Weyns, 2020; Cheng et al., 2009) 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 (Lovén et al., 2026b): the AI Service Markets framework (Lovén et al., 2026b) establishes that when service-dependency DAGs have tree or series-parallel structure, the feasible allocation region is polymatroidal and a Walrasian equilibrium exists under gross-substitutes valuations (Kelso and Crawford, 1982; Gul and Stacchetti, 1999). 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 operator-specified data sovereignty (which stage types may leave their originating domain) as a coordinate-wise 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) (Piri et al., 2016) 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 (Lovén et al., 2026b; Kelso and Crawford, 1982; Gul and Stacchetti, 1999)) 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 (LangChain, 2024), AutoGen (Wu et al., 2023), Anthropic MCP (Anthropic, 2024), Google A2A (Google, 2025)); 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 p≈2.8×10−14p≈ 2.8× 10^-14, Hodges–Lehmann median −39.6-39.6 ms, 95% bootstrap CI [−44.1,−35.3][-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%±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± 5 ms of an idealised 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 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%98.8\%→ 22.4\%→ 3.3\% across λ∈5,10,15λ∈\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%≥\,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 self-adaptive 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 (Kephart and Chess, 2003) and elaborated in IBM’s architectural blueprint (IBM, 2006) 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 (Salehie and Tahvildari, 2009) survey the landscape of self-adaptation under MAPE-K and adjacent reference models, Cheng et al. (Cheng et al., 2009) lay out a research roadmap for software engineering of self-adaptive systems, and Weyns (Weyns, 2020) integrates the contemporary toolbox (architecture-based adaptation, statistical model checking, learning-enabled adaptation) into a single textbook treatment. Parashar (Parashar, 2025) 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 placement planning, federated dispatch execution, and peer subscription summaries with bounded-staleness 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 continuum-level framing aligns directly with Parashar’s autonomic vision (Parashar, 2025): 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 (Saleh et al., 2025b) 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 (ETSI, 2014), ZSM (ETSI, 2019), ONAP (Linux Foundation Networking, 2024), O-RAN SMO (O-RAN Alliance, 2024a, b)) 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 (Xiong et al., 2018), K3s) manage container lifecycles, autoscaling, and scheduling. KubeEdge supports up to 100 000 edge nodes and provides offline operation with cloud synchronisation (Xiong et al., 2018). Modern batch schedulers Kueue (Kubernetes SIG Scheduling, 2024) and Volcano (Volcano Authors, 2024) 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 (Carbone et al., 2017) adds stateful stream processing with exactly-once semantics; and Ray (Moritz et al., 2018) 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 (Bisong, 2019), Argo Workflows, and MLflow (Zaharia et al., 2018) compose multi-stage AI pipelines as developer-defined DAGs on Kubernetes; KServe (KServe Contributors, 2024) and Triton (NVIDIA, 2024) 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; (i) scheduling operates within a single Kubernetes cluster (one administrative domain), with no federation protocol or cross-domain placement; and (i) 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. LLM-based agentic orchestration. LLM-based multi-agent frameworks (Guo et al., 2024) mark a static-to-dynamic transition at the task orchestration layer: statically declared graphs in AutoGen (Wu et al., 2023) and CrewAI (CrewAI, 2024) versus runtime-composed graphs in LangGraph (LangChain, 2024) and the OpenAI Agents SDK (OpenAI, 2025), with typed cross-framework surfaces such as Anthropic MCP (Anthropic, 2024) and Google A2A (Google, 2025). 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. (Saleh et al., 2025a) survey broker evolution for GenAI agents but identify no formal allocation mechanisms; model routers (OpenRouter (OpenRouter, 2025), LiteLLM (BerriAI, 2024), RouteLLM (Ong et al., 2024), (Not Diamond, 2024)) 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. (Beckman et al., 2020) and is reframed as an autonomic-management challenge by Parashar (Parashar, 2025). Workflow systems for the science-end of the continuum — Pegasus (Deelman et al., 2015), Parsl (Babuji et al., 2019), Swift (Wilde et al., 2011), CometCloud (Kim and Parashar, 2011) — 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 (Beckman et al., 2020); 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, single-cluster, 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 (Kephart and Chess, 2003; IBM, 2006; Salehie and Tahvildari, 2009; Cheng et al., 2009; Weyns, 2020; Parashar, 2025) in a federated, market-based substrate. 2.3. Publish/Subscribe Systems Publish/subscribe (pub/sub) decouples communicating endpoints in space, time, and synchronisation (Eugster and et al., 2003). Topic-based systems (Kafka, MQTT) route by partition or channel name; content-based systems evaluate filters over message attributes (Tarkoma, 2012). Carzaniga et al. (Carzaniga and et al., 2001) 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 (Tarkoma, 2012), 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 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 (Strinati and Barbarossa, 2021; Qin et al., 2022). Deep semantic codecs (DeepSC (Xie et al., 2021), DeepJSCC (Bourtsoulatze et al., 2019)) use Transformer-based joint source-channel coding under low-SNR conditions, and recent LLM-aware extensions (Zhang et al., 2024; Letaief et al., 2022) 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 (Bari et al., 2016) 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 (Lehmann et al., 2006; Nisan and Segal, 2006): without gross-substitutes structure, welfare-maximising allocation in combinatorial auctions is communication-complexity-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; (i) placement is decentralised across federated brokers using only summary information, trading optimality for vendor confidentiality; and (i) governance constructs (Section 4.6) are absent from classical SFC/VNE formulations. Classical DAG-scheduling baselines. List-scheduling heuristics on static DAGs (HEFT (Topcuoglu et al., 2002), PEFT, CPOP) target makespan minimisation under a fixed task graph and a known set of heterogeneous processors with deterministic compute and communication costs (Kwok and Ahmad, 1999; Graham, 1966). 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 (Liu et al., 2024), 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 (Lovén et al., 2021). Under high load, load-sensitive strategies can trigger cascading superfluous reallocations (“reallocation storms”) where up to 15–20% of all tasks are reallocated needlessly (Lovén et al., 2022); 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 (Kelso and Crawford, 1982; Gul and Stacchetti, 1999) provides the theoretical foundation for price-based allocation under gross-substitutes valuations; Ausubel’s ascending clinching auction (Ausubel, 2004) and its polyhedral extensions (Goel et al., 2015) implement this for polymatroidal feasible regions. Service-dependency DAGs and sovereignty constraints. The AI Service Markets framework of (Lovén et al., 2026b) 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 (Topkis, 1998; Milgrom and Roberts, 1990) — 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 (Guo et al., 2024) have produced frameworks for agentic orchestration (AutoGen (Wu et al., 2023), CrewAI (CrewAI, 2024), OpenAI Agents SDK (OpenAI, 2025)); emerging work on edge-deployed multi-LLM systems (e.g., (Luo et al., 2025)) 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. (Manias et al., 2024) 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 (P4 Language Consortium, 2023), INT (Kim et al., 2015)) 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 (Lovén et al., 2026a) 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 (Kelso and Crawford, 1982; Lovén et al., 2026b) and the MAPE-K reference model (Kephart and Chess, 2003; IBM, 2006); (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 / Argo and Kubernetes-side schedulers cover multi-stage but not cross-domain or semantic-aware allocation; SIENA (Carzaniga and et al., 2001) and content-based pub/sub (Tarkoma, 2012) cover cross-domain but not multi-stage or sovereignty; DeepSC (Xie et al., 2021) and 5G-semantic-routing (Manias et al., 2024) cover semantic matching but not pipelines; AI Service Markets (Lovén et al., 2026b) cover multi-stage / sovereignty / market but lack semantic matching; LLM multi-agent (Guo et al., 2024) cover only partial slices). The original Neural Pub/Sub paradigm appeared in (Lovén and et al., 2023); (Saleh et al., 2025a; Tarkoma et al., 2023) 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 (Lovén et al., 2026b) (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 πk,t _k,t 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 (1) Gres=(ℛ,E),G_res=(R,E), where a directed edge (r,r′)∈E(r,r )∈ E indicates that service r′r depends on service r. Each service v∈ℛv has a capacity CvC_v representing throughput (e.g., requests per second for an inference endpoint, cores for raw compute). Agents consume leaf services L(G)⊆ℛL(G) , the terminal nodes of the DAG that represent externally accessible service endpoints. Each internal node v constrains the aggregate throughput of its descendant leaves: the set of leaves reachable from v, denoted LvL_v, satisfies (2) ∑l∈Lvxl≤Cv, _l∈ L_vx_l≤ C_v, where xlx_l is the throughput allocated to leaf l. The service-feasibility region is the intersection of all such constraints: (3) res=≥0:x(Lv)≤Cv for every internal node v,X_res= \ x≥ 0:x(L_v)≤ C_v for every internal node v \, where x(S)=∑l∈Sxlx(S)= _l∈ Sx_l. 3.1.2. Polymatroidal Structure The shape of resX_res depends on the DAG topology. When GresG_res is a rooted tree or a two-terminal series-parallel network, the constraint families Lv\L_v\ form a laminar family (any two members are either nested or disjoint), and resX_res is a polymatroid with rank function (Lovén et al., 2026b) (4) f(S)=minA∑v∈ACv,f(S)= _A _v∈ AC_v, minimised over antichains A such that S⊆⋃v∈ALvS _v∈ AL_v. A polymatroid is the polytope ≥0:x(S)≤f(S)∀S⊆L(G)\ x≥ 0:x(S)≤ f(S)\;∀ S L(G)\ for a normalised, monotone, submodular rank function f (Fujishige, 2005). This structure enables efficient allocation via greedy algorithms or ascending auctions and incentive-compatible pricing under gross-substitutes valuations (Kelso and Crawford, 1982; Gul and Stacchetti, 1999; Lovén et al., 2026b). Why tree/SP DAGs induce laminar constraint families. A two-terminal SP digraph admits a binary parse tree (Duffin, 1965; Valdes et al., 1982) whose leaves are L(G)L(G); for every internal node v, LvL_v coincides with the descending parse-tree leaves, so Lv\L_v\ is laminar on L(G)L(G) (rooted trees are the single-edge-operand special case). Laminarity makes Eq. 4 monotone, normalised, and submodular, so resX_res is a polymatroid (Edmonds, 1970; Fujishige, 2005). General DAGs may destroy laminarity: the canonical obstruction is the diamond (K4K_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 (Lovén et al., 2026b) resolves general-DAG complexity through integrator encapsulation: an integrator manages a connected sub-DAG and exposes a composite service of scalar capacity (5) C¯j=max-flow(Gj). C_j=max -flow(G_j). Contracting each integrator yields a quotient graph G′G ; when G′G 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 ul≤Clu_l≤ C_l on leaf allocations (Lovén et al., 2026b); the governance-constrained region t=res∩govX_t=X_res _gov remains polymatroidal (intersection with coordinate-wise bounds preserves polymatroidal structure (Fujishige, 2005)). 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 GresG_res have tree or SP structure with laminar Lv\L_v\ on L(G)L(G), and let agents’ valuations on leaf-allocation slices satisfy gross-substitutes (GS) (Kelso and Crawford, 1982). Then a Walrasian equilibrium (∗,∗)( p^*, x^*) exists, ∗ x^* maximises social welfare, and the equilibrium is computable in polynomial time via an ascending polyhedral-clinching auction on the polymatroidal feasibility region (Ausubel, 2004; Goel et al., 2015). The result combines tree/SP polymatroidal structure (Fujishige, 2005; Lovén et al., 2026b) with Kelso–Crawford (Kelso and Crawford, 1982) and Gul–Stacchetti (Gul and Stacchetti, 1999). 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 k-means clusters. The single-broker matching layer’s design, calibration of τ, embedding model, and optional LLM-based cluster compression are companion-paper concerns ((Lovén et al., 2026a)); 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 (¯k,i,rk,i)( e_k,i,r_k,i) in Eq. 9 are rate-distortion-style summaries of the underlying subscription set, complementary to semantic-communication transport codecs (Xie et al., 2021; Bourtsoulatze et al., 2019; Strinati and Barbarossa, 2021) (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 (LangChain, 2024), AutoGen (Wu et al., 2023), Anthropic MCP (Anthropic, 2024), Google A2A (Google, 2025)) – where the matching layer 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 Gpipe=(V,E)G_pipe=(V,E): a map operation (1→F→11→ F→ 1) transforms a publisher’s event through a processing function F before delivery (e.g., classification, summarisation), and a funnel (N→F→1N→ F→ 1) aggregates events from multiple publishers (e.g., sensor fusion, federated aggregation). These patterns are analogous to MapReduce (Dean and Ghemawat, 2008) 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 GpipeG_pipe and execution units distributed across multiple administrative domains, the pipeline placement problem finds a mapping π:V→π:V 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 edge-cloud topology spanning two sites: • Edge site: Domains d1d_1 and d2d_2. Low-latency compute co-located with edge devices. Within-site latency <1<1 ms. • Cloud site: Domains d3d_3 and d4d_4. Abundant compute at higher latency. Within-site latency <1<1 ms. A single WAN link (∼ 50 ms) connects the two sites, representing the midhaul/backhaul boundary of the continuum. Each domain dk∈d_k is administratively independent, with its own governance policy kG_k, compute pool kN_k, 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 polymatroidal-tractability spectrum, parameterised by the non-modularity gap γ (the deficit of a constraint family from being laminar; γ=0γ=0 for tree/SP DAGs, γ>0γ>0 when the rank function fails submodularity, defined formally in Section 5.1): a linear chain (tree, γ=0γ=0), where Walrasian convergence holds directly; a fan-in series-parallel pattern (SP, γ=0γ=0), where convergence holds via the parse-tree argument of Section 3.1; and an entangled cross-tree fan-out/fan-in pattern (γ>0γ>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 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 (Kephart and Chess, 2003; IBM, 2006; Salehie and Tahvildari, 2009; Parashar, 2025). 4.1. Formal Model 4.1.1. Domains, Brokers, and Execution Units Let =d1,…,dmD=\d_1,…,d_m\ be a set of administrative domains, each governed by an independent operator. Each domain dkd_k contains: • A neural broker bkb_k implementing the content-matching layer of Section 3.3; • A set of execution units k=nk,1,…,nk,|k|N_k=\n_k,1,…,n_k,|N_k|\, each with computational capacity Ck,jC_k,j; • A set of locally registered publishers kP_k and subscribers kS_k. 4.1.2. AI Pipelines as Service-Dependency DAGs Following the AI Service Markets framework (Lovén et al., 2026b), an AI pipeline is modelled as a service-dependency DAG Gpipe=(V,E)G_pipe=(V,E), where each node v∈Vv∈ V represents a processing stage and each directed edge (v,v′)∈E(v,v )∈ E indicates that stage v′v depends on the output of stage v. Each stage v has a computational demand ρv _v and an output data rate ωv _v. A pipeline placement is a mapping π:V→⋃kπ:V→ _kN_k that assigns each stage to an execution unit. A placement is feasible if: (6) ∑v:π(v)=nk,jρv≤Ck,j∀k,j _v:π(v)=n_k,j _v≤ C_k,j ∀ k,j and, for every edge (v,v′)∈E(v,v )∈ E: (7) ℓ(π(v),π(v′))≤Lv,v′ (π(v),π(v ))≤ L_v,v where ℓ(⋅,⋅) (·,·) denotes the network latency and Lv,v′L_v,v is the latency bound. 4.1.3. Governance Constraints A governance policy kG_k for domain dkd_k specifies: • Data sovereignty: a set klocal⊆VT_k^local V of stage types whose inputs must not leave domain dkd_k; • Trust requirements: for cross-domain edges, a minimum trust level τk,k′ _k,k 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: (8) v∈klocal⟹π(v)∈kv _k^local π(v) _k 4.2. Broker Federation 4.2.1. Federation Overlay The brokers form a federation overlay ℱ=(ℬ,EF)F=(B,E_F) where ℬ=b1,…,bmB=\b_1,…,b_m\ and (bk,bk′)∈EF(b_k,b_k )∈ E_F if domains dkd_k and dk′d_k have established a federation agreement (mutual trust τk,k′>0 _k,k >0). 4.2.2. Subscription Aggregation and Propagation Each broker bkb_k maintains a local subscription index: a set of clusters ck,1,…,ck,pk\c_k,1,…,c_k,p_k\ 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 bkb_k is: (9) σk=(¯k,i,rk,i,κk,i):i=1,…,pk _k= \ ( e_k,i,\;r_k,i,\; _k,i ):i=1,…,p_k \ where ¯k,i e_k,i is the centroid embedding of cluster ck,ic_k,i, rk,ir_k,i is the cluster radius, and κk,i _k,i is the available capacity. 4.2.3. Cross-Domain Routing, Consistency, and Recovery When a publication arrives at broker bkb_k 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 score; O(m⋅p¯)O(m· p) comparison cost per publication using precomputed centroids. The overlay is asynchronous: peers exchange price summaries every δprop=10 _prop=10 s, with WANmax≈50WAN_ ≈ 50 ms giving a bounded staleness B≈10.05B≈ 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 _fed=5 s; on miss, the originating broker treats the peer as unreachable and falls back to local-only placement. The same δprop _prop-period channel doubles as the broker-liveness signal: after kmiss=3k_miss=3 consecutive failed pushes (≈30≈ 30 s) the peer is marked unhealthy, its σk _k 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 B 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 σk _k, peer price signals; Section 4.4) is bounded-staleness eventually consistent in the sense of probabilistically-bounded staleness (Bailis et al., 2014): any read at broker bkb_k reflects a peer state at most B seconds old, and across-peer convergence is guaranteed within one δprop _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 kmiss=3k_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 _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 B+δhealthB+ _health, consistent with the asynchronous, eventually-consistent semantics of Proposition 3.1. 4.2.4. Integrator Encapsulation Each domain’s broker acts as an integrator (Lovén et al., 2026b): it encapsulates the domain’s internal service-dependency structure into a composite service with scalar capacity: (10) C^kt=max⁡-flow(Gkt) C_k^t= -flow (G_k^t ) The federation-level allocation operates on the quotient graph G^=(^,E^) G=( D, E) where each domain is a single node. When G G is tree or series-parallel, the federation-level feasibility region is polymatroidal (Proposition 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 Proposition 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 nk,jn_k,j in domain dkd_k submits a bid WorkerBid(nk,j,t)=ck,j,tWorkerBid(n_k,j,t)=c_k,j,t for each stage type t, with ck,j,tc_k,j,t the opportunity cost increasing in utilisation (congestion pricing). The domain broker bkb_k computes per-stage-type clearing prices via marginal cost pricing, (11) πk,t=ck,(dt),t, _k,t=c_k,(d_t),t, where ck,(dt),tc_k,(d_t),t is the dtd_t-th cheapest worker’s cost for stage type t and dt=min⁡(demandt,supplyk,t)d_t= (demand_t,supply_k,t). Brokers exchange price signals (12) PriceSignal(dk)=(t,πk,t):t∈stage typesPriceSignal(d_k)=\(t, _k,t):t types\ alongside subscription summaries (preserving worker-identity privacy). For each stage of type t, the originating broker compares local and remote prices: (13) trade(t)=remoteif πk′,t+wWAN<πk,t,localotherwise,trade(t)= casesremote&if _k ,t+w_WAN< _k,t,\\ local&otherwise, cases with wWANw_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). Algorithm 1 Market-Based Pipeline Placement 1:Pipeline Gpipe=(V,E)G_pipe=(V,E), local domain dkd_k, worker bids, price signals from federation peers, WAN cost wWANw_WAN 2:Placement π:V→π:V or rejection 3: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. 4:Collect WorkerBids from all workers in dkd_k 5:Compute clearing prices πk,t _k,t for each stage type t via marginal cost pricing (Eq. 11); equal-cost bids ordered by ascending worker ID 6:Broadcast PriceSignal(dk)PriceSignal(d_k) to federation peers 7:for each stage v∈Vv∈ V in DAG topological order (Kahn’s, ties by ascending stage ID) do 8: t←type(v)t (v) 9: for each remote domain dk′d_k with price signal do 10: if πk′,t+wWAN<πk,t _k ,t+w_WAN< _k,t then 11: Mark v for remote placement in dk′d_k 12: end if 13: end for 14: Assign v to arg⁡min over feasible workers of cost-per-stage in the chosen domain (ties broken by ascending worker ID) 15: Accumulate cost 16:end for 17:if total cost >> pipeline value budget then 18: return rejection 19:end if 20:return placement π The clearing prices πk,t _k,t 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 Proposition 3.1; Section 5 tests how closely this practical mechanism matches the centralised oracle. 4.3.2. Implementation refinements The Walrasian mechanism in Proposition 3.1 is realised through five coupled components, each addressing a distinct gap that emerged during testbed validation: (i) speed-scaled bids bi=b0sib_i=b_0\,s_i at registration encode intrinsic worker capability (sis_i = relative processing speed) into the price signal independent of load (utilisation-based pricing alone produces only ∼2 2 ms price gaps at λ=5λ=5 pps, below any realistic WAN cost); (i) M/M/1 dynamic congestion pricing computes per-worker cost (14) costi=bi1−ρi,ρi=min⁡(ℓici, 0.99),cost_i= b_i1- _i, _i= \! ( _ic_i,\,0.99 ), with the ρi≤0.99 _i≤ 0.99 cap inside the formula bounding costmax=100bicost_ =100\,b_i (orders of magnitude above wWANw_WAN, so WAN-vs-local trade is dominated by genuine queue-depth signal); (i) federated price exchange (POST /federation/price-signal every δprop _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:→ℝ≥0 _add:U _≥ 0 tests ρv≤cu−ℓu−ℓadd(u) _v≤ c_u- _u- _add(u) 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 _health=5 s) keeps each broker’s view of ℓi _i — 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, 4.2 and 4.3 jointly close a MAPE-K control loop (Kephart and Chess, 2003; IBM, 2006) at each broker, framing Neural Pub/Sub as an autonomic substrate in the sense of self-adaptive software (Salehie and Tahvildari, 2009; Cheng et al., 2009; Weyns, 2020) (Fig. 2). The five elements are realised concretely as follows. MonitorHB / load probesAnalyseM/M/1 clearing πk,t _k,tExecutetrade rule (13)PlanAlgorithm 1Knowledgeσk _k, peer prices (B-stale) Figure 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, B≈10.05B≈ 10.05 s) rather than synchronously consistent. Monitor. Each broker tracks the health and load of its local workers via the periodic probe loop (δhealth=5 _health=5 s, Section 4.3.2) and tracks federation peers via the heartbeat-based partition detector (δprop=10 _prop=10 s exchange period, kmiss=3k_miss=3 consecutive misses; Section 4.2.3). The monitor produces per-worker queue depth ℓi _i (input to Eq. 14) and per-peer liveness, both with bounded latency. Analyse. The broker computes per-stage-type clearing prices πk,t _k,t from worker bids using the M/M/1 sojourn-time cost model (Eqs. 14 and 11). This is the marginal-cost analysis stage of the autonomic loop: it converts raw monitored state into decision-relevant signals, with the ρi≤0.99 _i≤ 0.99 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 π:V→⋃kπ:V→ _kN_k over the polymatroidal feasibility region t=res∩govX_t=X_res _gov (Section 3.1). Planning is local to each broker and uses cached peer prices for cross-domain trade decisions (Eq. 13). Proposition 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 _fed=5 s, Section 4.2.3), with the per-round reservation ledger ℓadd _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 σk=(¯k,i,rk,i,κk,i) _k=\( e_k,i,r_k,i, _k,i)\ (Eq. 9) for cross-domain semantic routing, and cached peer price signals PriceSignal(dk′)PriceSignal(d_k ) (Eq. 12) for cross-domain trade decisions. Both are bounded-staleness rather than synchronously consistent: the staleness bound B=δprop+WANmax≈10.05B= _prop+WAN_ ≈ 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 Proposition 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 B-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; Proposition 3.1’s mechanism), and three heuristics (locality-only, latency-greedy, spillover). All five honour slice constraints π(v)∈s(v)π(v) ^s(v) as a feasibility filter (5G/6G network slices (3GPP, 2024e, d, f, b) 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 (15) π∗=arg⁡minπ⁡[α∑(v,v′)∈Eℓ(π(v),π(v′))+β∑v∈VρvCπ(v)+ζ|k:∃v,π(v)∈k|]π^*= _π [α _(v,v )∈ E (π(v),π(v ) )+β _v∈ V _vC_π(v)+ζ |\k:∃ v,\,π(v) _k\ | ] 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 O(|V|⋅||2+|ℬ|log⁡W)O(|V|·|N|^2+|B| W) DP solution where |ℬ|≤m⋅||⋅W|B|≤ m·|T|· W is the bid-space cardinality and W=maxk⁡|k|W= _k|N_k|; general DAGs use greedy topological assignment in O(|V|⋅||+|ℬ|log⁡W)O(|V|·|N|+|B| W). When ζ>0ζ>0, the domain-crossings term breaks tree decomposition by a 2||2^|D| factor; with ||=4|D|=4 in the deployment this is bounded by 16 and dominated by the polynomial term at the testbed scale (|V|=8|V|=8, ||=48|N|=48). 4.6. Sovereignty Enforcement Scenarios The sovereignty module implements four enforcement scenarios at the site level (edge d1,d2\d_1,d_2\ and cloud d3,d4\d_3,d_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 (Carbone et al., 2017). For large-scale deployments (m>50m>50 domains), hierarchical federation reduces propagation cost from O(m2)O(m^2) to O(m)O(m); 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 (O-RAN Alliance, 2024a); the substrate is O-RAN-agnostic, and any four-administrative-domain 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 (3GPP, 2024a, c) (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 d1d_1 (DU, 12 URLLC workers) and Domain d2d_2 (CU + near-RT RIC, 12 mixed URLLC/eMBB workers). Represents cell-site and edge compute. • Cloud site (2 VMs): Domain d3d_3 (non-RT RIC, 12 eMBB workers) and Domain d4d_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γ=0): DU:raw_cqi→DU:denoise→CU:normalise→CU:feature_extract→RIC:predict→RIC:validate→nRT:aggregate→SMO:reportDU:raw\_cqi :denoise :normalise :feature\_extract :predict :validate :aggregate :report. Linear chain crossing all 4 domains. 8 stages, 7 edges. (2) RAN Anomaly Detection (series-parallel, γ=0γ=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γ>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 ρv _v 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)(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λ∈\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λ∈\5,8,10,15,50\ pps to sweep across and beyond the empirical saturation knee at ∼13.8 13.8 pps (calibrated via a dedicated sweep, scripts/calibrate_saturation.py). The saturation knee (∼13.8 13.8 pps, 95% CI [12.5,14.6][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λ∈\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 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 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 p≈2.8×10−14p≈ 2.8× 10^-14, Hodges–Lehmann median −39.6-39.6 ms, 95% bootstrap CI [−44.1,−35.3][-44.1,-35.3] ms); a fair-process-count sharded-oracle comparator (4 coordinator processes) keeps the gap within ±1.5%± 1.5\% across all 9 cells, with the market dominating on cqi-chain (3/3) and trading within ±5± 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 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%≥\,98.7\% across 75 federation and resilience cells (Section 5.7). (4) Sovereignty enforcement adds zero observable runtime overhead. Across 60 governance-grid 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λ=5 pps single-VM, per-seed latency differences between HTTP and Kafka are <1<1 ms for round-robin and random placements; neural placement adds ∼8 8 ms under Kafka relative to HTTP (Kafka consumer dispatch, <2%<2\% of total). All strategies achieve near-identical performance under homogeneous single-site conditions (∼1231 1231 ms median, ≥99%≥ 99\% completion). (i) Slice-aware placement reduces median latency by 15% under HTTP (1233 vs 1450 ms) and increases throughput 5×5× in the equalised B1eq-vs-B2 comparison. (i) 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 t=5t=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≈6 ms (0.5%) and the HTTP-vs-Kafka mean-latency gap to ≤1≤ 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: (16) Δeff=1−ηmarketηoracle, _eff=1- _market _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 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 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. Table 1. Pipeline-aggregated mean end-to-end latency (ms) for the four-broker market and the fair-process-count 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± 1 ms; 3 load levels per pipeline). The full per-cell single-process oracle / market / sharded comparison is in Table S1. Pipeline Market mean Sharded mean Δ Cell wins (mkt/OS/tie) cqi-chain (tree) 1822 1848 −26-26 (1.4%1.4\%) 3 / 0 / 0 anomaly-sp (SP) 1201 1201 tied 1 / 2 / 0 ran-entangled 965 971 −7-7 (0.7%0.7\%) 1 / 1 / 1 Across the 9 (pipeline, load) cells × 5 seeds the four-broker market trades within ±1.5%± 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± 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± 5 ms on series-parallel and entangled DAGs. The decentralised-vs-centralised inversion observed against the single-process oracle (a ∼3% 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. (a) Near-optimality: market vs single-process oracle, all cells. (b) Round-robin CR collapse 98.8%→22.4%→3.3%98.8\%→ 22.4\%→ 3.3\%. (c) Heuristic strategy parity under uniform load. (d) Sovereignty-enforcement grid: zero runtime overhead across four scenarios. Figure 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%98.8\%→ 22.4\%→ 3.3\% across λ∈5,10,15λ∈\5,10,15\ pps; (c) heuristic strategy parity under uniform load (CDFs of mean latency for the four decentralised strategies); (d) sovereignty-enforcement grid showing zero runtime overhead across four enforcement scenarios. 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 |L¯market−L¯oracle|<1| L_market- L_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%± 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± 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 p=2−45≈2.8×10−14p=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-39.6 ms with a percentile bootstrap 95% CI of [−44.1,−35.3][-44.1,\,-35.3] ms (B=10,000B=10,000 resamples), confirming a robust market advantage well-bounded 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 B≈10.05B≈ 10.05 s (Section 4.2.3) sets a price-signal-lag ceiling: up to λB≈139λ B≈ 139 pipelines may arrive at one broker between exchanges; the within-round reservation ledger (Section 4.3.2) absorbs this transient locally because over-allocation 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λ≤ 10 pps loads we test rather than the λ>13.8λ>13.8 pps regime where staleness would dominate. The pipeline-structure 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 agent-facing 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. 5.6. 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±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. 3(c). 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. 3(b)). The conventional round-robin orchestrator drops from CR = 98.8% at λ=5λ=5 pps to 22.4% at λ=10λ=10 pps to 3.3% at λ=15λ=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λ≈13.8 pps. The market mechanism, by contrast, holds CR = 100% at λ≤10λ≤ 10 pps and degrades gracefully thereafter (83.3% at λ=15λ=15 pps; 25.4% at λ=50λ=50 pps where r-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 n=5n=5 seeds for sharded; market partial n=4n=4 at sat-15). At the saturation regime (λ=15λ=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 r-global collapses. The single-process oracle’s sat-15 cell is partial (n=2n=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, r-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×2× slower and cloud workers 1.5×1.5× faster, r-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%≈ 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); (i) failure-times-load tests information completeness (price encodes worker availability immediately, vs the round-robin health-check loop); (i) heterogeneity tests price discovery (scarce workers become expensive at equilibrium, vs identical treatment). These three properties are independent of GS (Proposition 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%≥ 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 per-stage level: across both edge sites (eMBB-kill on VM2, URLLC-kill on VM1), neural-placement (S3) worker death mid-experiment yields CR ≥99.9%≥ 99.9\% across 36,098 events (VM1) and 36,092 (VM2). 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. 3(d)) 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 domain-level 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 Proposition 3.1; the gap between simplified and optimal pricing is part of the measured Δeff _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 _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 kmiss=3k_miss=3 failover regime begin to misclassify peers as unhealthy. Cross-site validation on real WAN infrastructure (Oulu↔ , ∼150 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 multi-level 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 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. Discussion 6.1. 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. Proposition 3.1 is scale-independent, but Δeff _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 Proposition 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 (Morris et al., 2023) 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 (Ausubel, 2004; Goel et al., 2015) (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 (Lovén et al., 2026b), enabling a three-level deployment gradient: (i) internal priority scheduling (single domain, synthetic priority tokens, minimal governance — no real economy needed), (i) federated priority (cross-domain, shared priority-token price signals via Section 4.3), and (i) 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 (O-RAN Alliance, 2024c)). 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 (Lovén et al., 2021, 2022); 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 (Kueue (Kubernetes SIG Scheduling, 2024), Volcano (Volcano Authors, 2024)) 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-control-plane 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 to hundreds of workers per domain via hierarchical broker federation has O(m⋅p¯)O(m· p) federation cost (Section 4.7); validation via EISim (Kokkonen et al., 2023) is future work. HPC-tier integration. The Special Issue spans the edge–HPC/cloud continuum (Beckman et al., 2020; Parashar, 2025); 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 10 s bounded-staleness regime of Section 5.5: bulk-synchronous HPC queueing introduces wait-time variance at the 10210^2–10310^3 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 B=δprop+WANmax≈10.05B= _prop+WAN_ ≈ 10.05 s, arrival rate λ≤13.8λ≤ 13.8 pps for the round-robin saturation knee with λB≤139λ B≤ 139 pipelines absorbed by the within-round reservation ledger, and federation peer-liveness misclassification bounded by the kmiss=3k_miss=3 failover regime under the δprop=10 _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 ρi≥0.99 _i≥ 0.99 (admission-control guarantee from the ρi _i cap in Eq. 14), (i) no within-round over-commitment exceeds a single pipeline’s stage count (reservation-ledger invariant), and (i) sovereignty constraints are coordinate-wise upper bounds on the feasibility region and cannot be violated by any market-clearing decision (Section 4.1). Liveness rests on the eventual-consistency reading of Proposition 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 (Calinescu et al., 2012; Tamura et al., 2013; Weyns, 2020) 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 multi-vendor deployments; broker accountability (commitment-based pricing, cross-broker auditing, coalition deterrence) integrated with the federation protocol is future work. Dynamic credibility and 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 (Xie et al., 2021; Qin et al., 2022) 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 (Proposition 3.1, Section S2 of the electronic supplement): under gross-substitutes valuations on tree and series-parallel 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 fair-process-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 p≈2.8×10−14p≈ 2.8× 10^-14); against the fair-process-count four-shard centralised oracle the gap is within ±1.5%± 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%98.8\%→ 22.4\%→ 3.3\% across λ∈5,10,15λ∈\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%≥\,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 (Kokkonen et al., 2023) to production-scale deployments, broker-accountability mechanisms (commitment-based 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 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. S1. 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 near-optimality 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 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%± 1.5\% across all 9 cells. Table S1. Mean end-to-end latency (ms) for single-process oracle (Oracle1), four-broker market, and four-shard 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. Pipeline Load Oracle1 Market Oracle4 M−-O1 SE M−-O4 cqi-chain (tree) low (2 pps) 1852 1792 1806 −60-60 0.8 −14-14 cqi-chain medium (5 pps) 1874 1824 1838 −50-50 1.7 −14-14 cqi-chain high (10 pps) 1908 1852 1901 −56-56 11.8 −49-49 anomaly-sp (SP) low 1199 1170 1165 −29-29 0.4 +5+5 anomaly-sp medium 1237 1186 1184 −51-51 0.6 +2+2 anomaly-sp high 1285 1246 1253 −39-39 1.9 −7-7 ran-entangled low 973 948 946 −25-25 0.6 +2+2 ran-entangled medium 992 958 959 −34-34 0.8 −1-1 ran-entangled high 1008 988 1010 −20-20 2.6 −22-22 Table S2 reports tail-latency percentiles (p50, p95, p99) for the four-broker market and the single-process 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+23 ms and within run-to-run noise (the 99th-percentile estimate fluctuates by ±30±30 ms across seeds at ∼40,000 40,000 events per cell). The directional signal of Table S1 is consistent at p50 / p95 / p99 with the mean-latency comparison. 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 Market Pipeline Load p50 p95 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 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±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. Table S3. Mean latency (ms) across decentralised strategies under uniform conditions; all four converge. Pipeline Load Market Locality Lat-greedy Spillover cqi-chain low 1792 1791 1797 1794 cqi-chain med 1824 1819 1828 1825 cqi-chain high 1852 1845 1849 1846 anomaly-sp low 1170 1170 1174 1173 anomaly-sp med 1186 1189 1192 1190 anomaly-sp high 1246 1240 1248 1240 ran-entangled low 948 950 949 949 ran-entangled med 958 963 962 961 ran-entangled high 988 995 993 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± 15 ms across every load and report identical completion rates within 0.5 percentage points; r-global collapses dramatically at λ≥10λ≥ 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) sat-10 (10 pps) CR% mean ms CR% mean ms oracle (single-process) 100.0 1872 100.0 1888 market (4-broker) 100.0 1845 100.0 1845 oracle (4-shard) 100.0 1832 100.0 1853 r-global 95.5 1999 19.9 4803 sat-15 (15 pps): saturation regime oracle (single-process) 74.1% / 2331 ms (n=2) market (4-broker) 83.3% / 2091 ms (n=4) oracle (4-shard) 83.8% / 2105 ms r-global 3.3% / 10981 ms 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λ=10 pps and degrades gracefully thereafter (CR = 25.4% at λ=50λ=50 pps where r-global is 0%). Stress dimension Scenario Description r-global CR% r-global mean (ms) Saturation (no failure) sat-5 λ=5λ=5 pps, no failure 98.8 1843 sat-10 λ=10λ=10 pps, no failure 22.4 3395 sat-15 λ=15λ=15 pps, no failure 3.3 9598 Failure × load failure-5-12 λ=5λ=5 pps, kill 12 workers 96.7 1940 failure-8-12 λ=8λ=8 pps, kill 12 workers 33.5 3262 failure-10-12 λ=10λ=10 pps, kill 12 workers 22.5 3708 Heterogeneity het 2× slow edge / 1.5× fast cloud workers 94.3 2508 S1.3. 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=605×3×4=60 runs). All four scenarios are within ±3± 3 ms of each other across every pipeline, demonstrating zero measurable runtime overhead from sovereignty enforcement (Finding 4 of the main paper). Table S6. Sovereignty-enforcement grid: mean latency (ms) across four enforcement scenarios. All scenarios are within ±3± 3 ms of each other across every pipeline. Pipeline none edge-only cloud-only both cqi-chain 1824 1825 1826 1826 anomaly-sp 1188 1188 1191 1190 ran-entangled 959 960 960 960 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 (Lovén et al., 2026b). 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 Gres=(ℛ,E)G_res=(R,E) be a service-dependency DAG with capacities Cvv∈ℛ\C_v\_v and leaf services L(G)⊆ℛL(G) , defining the service-feasibility region resX_res of the main paper (Eq. (3)). Let t=res∩govX_t=X_res _gov be the governance-constrained feasibility region (main paper, Eq. (8)). Conditions. (1) Laminar structure. The constraint family Lv:v∈ℛ∖L(G)\L_v:v L(G)\ is laminar on L(G)L(G): for any two members Lv,Lv′L_v,L_v , either Lv⊆Lv′L_v L_v , Lv′⊆LvL_v L_v, or Lv∩Lv′=∅L_v∩ L_v = . This holds in particular when GresG_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), resX_res is a polymatroid with rank function f defined by Eq. (4) of the main paper (Edmonds, 1970; Fujishige, 2005). Coordinate-wise governance bounds preserve polymatroidal structure; therefore tX_t is also polymatroidal. (3) Gross-substitutes valuations. Each agent’s valuation over leaf-allocation slices satisfies the gross-substitutes (GS) condition of (Kelso and Crawford, 1982). This condition is non-trivial: pipeline-bundle valuations are perfect-complements (Leontief) on the raw stage set, and the GS-compatible representation arises only after integrator encapsulation (Lovén et al., 2026b), 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: vraw(x)=v⋆⋅[x≥V]v_raw(x)=v ·1[x 1_V] on 0,1V\0,1\^V, 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 v(x)=v⋆⋅[x≥D]v(x)=v ·1[x 1_D] is unit-demand-per-domain on the integrator quotient. Unit-demand satisfies GS (Kelso and Crawford, 1982), so the buyer-facing layer is GS by construction and the non-modularity gap γ of the main paper’s §5.1 is γ=0γ=0 post-quotient. “Residual encapsulation losslessness” (the integrator’s max-flow, main paper Eq. (10), is achieved without an internal sub-DAG bottleneck, so the composite item’s unit demand is realisable) is the load-bearing assumption deferred to (Lovén et al., 2026b). Statement and where the proof lives. Under conditions (1)–(3): (a) a Walrasian equilibrium (∗,∗)( p^*, x^*) exists; (b) ∗ x^* maximises social welfare ∑ivi(xi∗) _iv_i(x_i^*); (c) (∗,∗)( p^*, x^*) is computable in polynomial time by an ascending polyhedral-clinching auction (Ausubel, 2004; Goel et al., 2015) on the polymatroidal region tX_t. Conditions (1)–(2) are classical (Edmonds, 1970; Fujishige, 2005); (a)–(b) follow from Kelso–Crawford (Kelso and Crawford, 1982) and Gul–Stacchetti (Gul and Stacchetti, 1999) given the polymatroidal structure; the AI-pipeline construction and the integrator-encapsulation reduction are in (Lovén et al., 2026b); (c) follows from (Ausubel, 2004; Goel et al., 2015). 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 near-RT RIC), and ran-entangled becomes laminar after integrator encapsulation (Lovén et al., 2026b) 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 3GPP (2024a) 3GPP TS 23.288: architecture enhancements for 5G system (5GS) to support network data analytics services. Technical report Technical Report TS 23.288 V18.6.0, 3rd Generation Partnership Project. Note: Release 18 Cited by: §5.1. 3GPP (2024b) 3GPP TS 28.541: management and orchestration; 5G network resource model (NRM); stage 2 and stage 3. Technical report Technical Report TS 28.541 V18.7.0, 3rd Generation Partnership Project. Note: Release 18 Cited by: §4.5. 3GPP (2024c) 5G; architecture enhancements for 5G system (5GS) to support network data analytics services (3GPP TS 23.288). Note: Technical Specification, Release 18Accessed 2026-05-04 Cited by: §5.1. 3GPP (2024d) 5G; procedures for the 5G system (5GS) (3GPP TS 23.502). Note: Technical Specification, Release 18 Cited by: §4.5. 3GPP (2024e) 5G; system architecture for the 5G system (5GS) (3GPP TS 23.501). Note: Technical Specification, Release 18 Cited by: §4.5. 3GPP (2024f) Management and orchestration; concepts, use cases and requirements (3GPP TS 28.530). Note: Technical Specification, Release 18 Cited by: §4.5. Anthropic (2024) Model context protocol (MCP). Note: https://modelcontextprotocol.io Cited by: item 1, §2.2, §3.3. L. M. Ausubel (2004) An efficient ascending-bid auction for multiple objects. American Economic Review 94 (5), p. 1452–1475. Cited by: §2.5, §S2, Proposition 3.1, §6.1. Y. Babuji, A. Woodard, Z. Li, D. S. Katz, B. Clifford, R. Kumar, L. Lacinski, R. Chard, J. M. Wozniak, I. Foster, M. Wilde, and K. Chard (2019) Parsl: pervasive parallel programming in python. In Proceedings of the 28th International Symposium on High-Performance Parallel and Distributed Computing (HPDC), p. 25–36. Cited by: §2.2. P. Bailis, S. Venkataraman, M. J. Franklin, J. M. Hellerstein, and I. Stoica (2014) Quantifying eventual consistency with pbs. In Communications of the ACM, Vol. 57, p. 93–102. Cited by: §4.2.3. Md. F. Bari, S. R. Chowdhury, R. Ahmed, R. Boutaba, and O. C. M. B. Duarte (2016) Orchestrating virtualized network functions. IEEE Transactions on Network and Service Management 13 (4), p. 725–739. Cited by: §2.5. P. Beckman, J. Dongarra, N. Ferrier, G. Fox, T. Moore, D. Reed, and M. Beck (2020) Harnessing the computing continuum for programming our world. Fog Computing: Theory and Practice, p. 215–230. Cited by: §2.2, §6.2. BerriAI (2024) LiteLLM: call all LLM APIs using the OpenAI format. Note: Accessed 2026-05-04. https://docs.litellm.ai/docs/routing Cited by: §2.2. E. Bisong (2019) Kubeflow and kubeflow pipelines. In Building Machine Learning and Deep Learning Models on Google Cloud Platform, p. 671–685. Cited by: §1, §2.2. E. Bourtsoulatze, D. B. Kurka, and D. Gündüz (2019) Deep joint source-channel coding for wireless image transmission. In IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), p. 4514–4518. Cited by: §2.4, §3.3. R. Calinescu, C. Ghezzi, M. Kwiatkowska, and R. Mirandola (2012) Self-adaptive software needs quantitative verification at runtime. Communications of the ACM 55 (9), p. 69–77. Cited by: §6.3. P. Carbone, S. Ewen, G. Fóra, S. Haridi, S. Richter, and K. Tzoumas (2017) State management in Apache Flink: consistent stateful distributed stream processing. Proceedings of the VLDB Endowment 10 (12), p. 1718–1729. Cited by: §1, §2.2, §4.7. A. Carzaniga and et al. (2001) Design and evaluation of a wide-area event notification service. ACM Transactions on Computer Systems (TOCS) 19 (3), p. 332–383. Cited by: §2.3, §2.6. B. H. C. Cheng, R. de Lemos, H. Giese, P. Inverardi, J. Magee, J. Andersson, B. Becker, N. Bencomo, Y. Brun, B. 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, p. 1–26. Cited by: §1, §2.1, §2.2, §4.4. CrewAI (2024) CrewAI: framework for orchestrating role-playing autonomous AI agents. Note: https://w.crewai.com Cited by: §2.2, §2.5. J. Dean and S. Ghemawat (2008) MapReduce: simplified data processing on large clusters. Communications of the ACM 51 (1), p. 107–113. Cited by: §3.3.1. E. Deelman, K. Vahi, G. Juve, M. Rynge, S. Callaghan, P. J. Maechling, R. Mayani, W. Chen, R. Ferreira da Silva, M. Livny, and K. Wenger (2015) Pegasus, a workflow management system for science automation. Future Generation Computer Systems 46, p. 17–35. Cited by: §2.2. R. J. Duffin (1965) Topology of series-parallel networks. Journal of Mathematical Analysis and Applications 10 (2), p. 303–318. Cited by: §3.1.2. J. Edmonds (1970) Submodular functions, matroids, and certain polyhedra. In Combinatorial Structures and their Applications (Proc. Calgary Internat. Conf., 1969), p. 69–87. Cited by: item 2, §S2, §3.1.2. ETSI (2014) Network functions virtualisation (NFV); management and orchestration (GS NFV-MAN 001). Note: Group Specification Cited by: §2.2. ETSI (2019) Zero-touch network and service management (ZSM); reference architecture (GS ZSM 002). Note: Group Specification Cited by: §2.2. P. T. Eugster and et al. (2003) The many faces of publish/subscribe. ACM computing surveys (CSUR) 35 (2), p. 114–131. Cited by: §2.3. S. Fujishige (2005) Submodular functions and optimization. 2 edition, Elsevier. Cited by: item 2, §S2, §3.1.2, §3.1.2, §3.1.3, §3.2. G. Goel, V. Mirrokni, and R. P. Leme (2015) Polyhedral clinching auctions and the adwords polytope. Journal of the ACM 62 (3), p. 1–27. Cited by: §2.5, §S2, Proposition 3.1, §6.1. Google (2025) Agent2Agent (A2A) protocol. Note: https://a2a-protocol.org Cited by: item 1, §2.2, §3.3. R. L. Graham (1966) Bounds for certain multiprocessing anomalies. Bell System Technical Journal 45 (9), p. 1563–1581. Cited by: §2.5. F. Gul and E. Stacchetti (1999) Walrasian equilibrium with gross substitutes. Journal of Economic Theory 87 (1), p. 95–124. Cited by: item 1, §1, §2.5, §S2, §3.1.2, §3.2. T. Guo, X. Chen, Y. Wang, R. Chang, S. Pei, N. V. Chawla, O. Wiest, and X. Zhang (2024) Large language model based multi-agents: a survey of progress and challenges. arXiv preprint arXiv:2402.01680. Cited by: §2.2, §2.5, §2.6. IBM (2006) An architectural blueprint for autonomic computing. 4 edition. Note: IBM White Paperhttps://w-03.ibm.com/autonomic/pdfs/AC%20Blueprint%20White%20Paper%20V7.pdf Cited by: §1, §1, §2.1, §2.2, §2.6, §4.4, §4. A. S. Kelso and V. P. Crawford (1982) Job matching, coalition formation, and gross substitutes. Econometrica 50 (6), p. 1483–1504. Cited by: item 1, §1, item 3, §2.5, §2.6, §S2, §S2, §3.1.2, §3.2, Proposition 3.1. J. O. Kephart and D. M. Chess (2003) The vision of autonomic computing. Computer 36 (1), p. 41–50. External Links: Document Cited by: §1, §1, §2.1, §2.2, §2.6, §4.4, §4. C. Kim, A. Sivaraman, N. Katta, A. Bas, A. Dixit, and L. J. Wobker (2015) In-band network telemetry via programmable dataplanes. In ACM SIGCOMM Demo, Cited by: §2.5. H. Kim and M. Parashar (2011) CometCloud: an autonomic cloud engine. In Cloud Computing: Principles and Paradigms, p. 275–297. Cited by: §2.2. H. Kokkonen, S. Pirttikangas, and L. Lovén (2023) EISim: a platform for simulating intelligent edge orchestration solutions. In Proc. IEEE/ACM Symposium on Edge Computing (SEC), Poster Session, p. 1–2. Note: Open-source: https://github.com/hennas/EISim Cited by: §6.2, §7. KServe Contributors (2024) KServe: highly scalable and standards based model inference platform on Kubernetes. Note: https://kserve.github.io/website/Accessed 2026-05-04 Cited by: §2.2. Kubernetes SIG Scheduling (2024) Kueue: kubernetes-native job queueing. Note: https://kueue.sigs.k8s.io/Accessed 2026-05-04 Cited by: §1, §2.2, §6.2. Y. Kwok and I. Ahmad (1999) Static scheduling algorithms for allocating directed task graphs to multiprocessors. ACM Computing Surveys 31 (4), p. 406–471. Cited by: §2.5. LangChain (2024) LangGraph: agent runtime and orchestration framework. Note: Accessed 2026-05-04. https://w.langchain.com/langgraph Cited by: item 1, §2.2, §3.3. B. Lehmann, D. Lehmann, and N. Nisan (2006) Combinatorial auctions with decreasing marginal utilities. Games and Economic Behavior 55 (2), p. 270–296. Cited by: §2.5. K. B. Letaief, Y. Shi, J. Lu, and J. Lu (2022) Edge artificial intelligence for 6G: vision, enabling technologies, and applications. IEEE Journal on Selected Areas in Communications 40 (1), p. 5–36. External Links: Document Cited by: §2.4. Linux Foundation Networking (2024) ONAP architecture overview (Open Network Automation Platform). Note: https://w.onap.org/Accessed 2026-05-04 Cited by: §2.2. X. Liu, J. Liu, H. Wu, and J. Dong (2024) A family of truthful mechanisms for resource allocation with multi-attribute demand in mobile edge computing. Cluster Computing 27, p. 11595–11610. External Links: Document Cited by: §2.5. L. 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. Cited by: §2.6. L. Lovén, A. Kumar, A. Engelhardt, A. Saleh, R. Morabito, X. Liu, N. H. Motlagh, and S. Tarkoma (2026a) Neural router: semantic content matching for agentic ai. arXiv preprint arXiv:2605.25701. Cited by: §2.6, §3.3. L. Lovén, E. Peltonen, E. Harjula, and S. 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), p. 317–322. External Links: Document Cited by: §2.5, §6.2. L. Lovén, E. Peltonen, L. Ruha, E. Harjula, and S. Pirttikangas (2022) A dark and stormy night: reallocation storms in edge computing. EURASIP Journal on Wireless Communications and Networking 2022 (1), p. 86. External Links: Document Cited by: §2.5, §6.2. L. Lovén, A. Saleh, R. Farahani, I. Murturi, M. Bordallo López, P. K. Donta, and S. Dustdar (2026b) Real-time AI service economy: a framework for agentic computing across the continuum. arXiv preprint arXiv:2603.05614. Cited by: item 1, §1, item 3, §2.5, §2.6, §S2, §S2, §S2, §S2, §3.1.2, §3.1.2, §3.1.3, §3.1.3, §3.2, §3, §4.1.2, §4.2.4, §6.2. H. Luo, Y. Liu, R. Zhang, J. Wang, G. Sun, D. Niyato, H. Yu, Z. Xiong, X. Wang, and X. Shen (2025) Toward edge general intelligence with multiple-large language model (Multi-LLM): architecture, trust, and orchestration. arXiv preprint arXiv:2507.00672. Cited by: §2.5. D. M. Manias, A. Chouman, and A. Shami (2024) Semantic routing for enhanced performance of LLM-assisted intent-based 5G core network management and orchestration. In IEEE Global Communications Conference (GLOBECOM), p. 1–6. Cited by: §2.5, §2.6. P. Milgrom and J. Roberts (1990) Rationalizability, learning, and equilibrium in games with strategic complementarities. Econometrica 58 (6), p. 1255–1277. Cited by: §2.5. P. Moritz, R. Nishihara, S. Wang, A. Tumanov, R. Liaw, E. Liang, M. Elibol, Z. Yang, W. Paul, M. I. Jordan, and I. Stoica (2018) Ray: a distributed framework for emerging AI applications. In USENIX Symposium on Operating Systems Design and Implementation (OSDI), p. 561–577. Cited by: §1, §2.2. J. X. Morris, V. Kuleshov, V. Shmatikov, and A. M. Rush (2023) Text embeddings reveal (almost) as much as text. In Proc. EMNLP, Cited by: §6.1. N. Nisan and I. Segal (2006) The communication requirements of efficient allocations and supporting prices. Journal of Economic Theory 129 (1), p. 192–224. Cited by: §2.5. Not Diamond (2024) Not Diamond: intelligent AI model routing. Note: Accessed 2026-05-04. https://docs.notdiamond.ai/docs/what-is-model-routing Cited by: §2.2. NVIDIA (2024) NVIDIA Triton Inference Server. Note: https://developer.nvidia.com/triton-inference-serverAccessed 2026-05-04 Cited by: §2.2. O-RAN Alliance (2024a) O-RAN architecture description (O-RAN.WG1.OAD). Note: Technical Specification, R003Accessed 2026-05-04 Cited by: §2.2, §5.1. O-RAN Alliance (2024b) O-RAN non-RT RIC architecture (O-RAN.WG2.Non-RT-RIC-ARCH). Note: Technical SpecificationAccessed 2026-05-04 Cited by: §2.2. O-RAN Alliance (2024c) O-RAN security requirements and controls specification (O-RAN.WG11.Security-Requirements-Spec). Note: Technical SpecificationAccessed 2026-05-04 Cited by: §6.2. I. Ong, A. Almahairi, V. Wu, W. Chiang, T. Wu, J. E. Gonzalez, M. W. Kadous, and I. Stoica (2024) RouteLLM: learning to route LLMs with preference data. Note: arXiv preprint arXiv:2406.18665 Cited by: §2.2. OpenAI (2025) OpenAI agents SDK. Note: https://github.com/openai/openai-agents-python Cited by: §2.2, §2.5. OpenRouter (2025) OpenRouter: unified API for AI models with intelligent provider routing. Note: Accessed 2026-05-04. https://openrouter.ai/docs/guides/routing/provider-selection Cited by: §2.2. P4 Language Consortium (2023) P4Runtime specification. Note: https://p4.org/p4-spec/p4runtime/main/P4Runtime-Spec.htmlAccessed 2026-05-04 Cited by: §2.5. M. Parashar (2025) Everywhere and nowhere: envisioning a computing continuum for science. Computing in Science & Engineering 27 (1), p. 51–56. External Links: Document Cited by: §1, §2.1, §2.1, §2.2, §2.2, §4, §6.2. E. Piri, P. Ruuska, T. Kanstrén, J. Mäkelä, J. Korva, A. Hekkala, A. Pouttu, O. Liinamaa, M. Latva-aho, K. Vierimaa, and H. Valasma (2016) 5GTN: a test network for 5G application development and testing. In 2016 European Conference on Networks and Communications (EuCNC), p. 313–318. External Links: Document Cited by: §1. Z. Qin, X. Tao, J. Lu, W. Tong, and G. Y. Li (2022) Semantic communications: principles and challenges. arXiv preprint arXiv:2201.01389. Cited by: §2.4, §6.4. A. Saleh, R. Morabito, S. Dustdar, S. Tarkoma, S. Pirttikangas, and L. Lovén (2025a) Towards message brokers for generative AI: survey, challenges, and opportunities. ACM Computing Surveys 58 (1), p. 1–37. External Links: Document Cited by: §2.2, §2.6. A. Saleh, S. Tarkoma, A. Lindgren, P. K. Donta, S. Dustdar, S. Pirttikangas, and L. Lovén (2025b) Memindex: agentic event-based distributed memory management for multi-agent systems. ACM Transactions on Autonomous and Adaptive Systems. External Links: Document Cited by: §2.1. M. Salehie and L. Tahvildari (2009) Self-adaptive software: landscape and research challenges. ACM Transactions on Autonomous and Adaptive Systems (TAAS) 4 (2), p. 1–42. External Links: Document Cited by: §1, §2.1, §2.2, §4.4, §4. E. C. Strinati and S. Barbarossa (2021) 6G networks: beyond Shannon towards semantic and goal-oriented communications. Computer Networks 190, p. 107930. External Links: Document Cited by: §2.4, §3.3. G. Tamura, N. M. Villegas, H. A. Müller, J. P. Sousa, B. Becker, G. Karsai, S. Mankovskii, M. Pezzè, B. Schmerl, L. Tahvildari, and K. Wong (2013) Towards practical runtime verification and validation of self-adaptive software systems. In Software Engineering for Self-Adaptive Systems I (LNCS 7475), p. 108–132. Cited by: §6.3. S. Tarkoma, R. Morabito, and J. Sauvola (2023) AI-native interconnect framework for integration of large language model technologies in 6G systems. arXiv preprint arXiv:2311.05842. Cited by: §2.6. S. Tarkoma (2012) Publish/subscribe systems: design and principles. John Wiley & Sons. Cited by: §2.3, §2.6. H. Topcuoglu, S. Hariri, and M. Wu (2002) Performance-effective and low-complexity task scheduling for heterogeneous computing. IEEE Transactions on Parallel and Distributed Systems 13 (3), p. 260–274. Cited by: §2.5. D. M. Topkis (1998) Supermodularity and complementarity. Princeton University Press. Cited by: §2.5. J. Valdes, R. E. Tarjan, and E. L. Lawler (1982) The recognition of series parallel digraphs. SIAM Journal on Computing 11 (2), p. 298–313. Cited by: §3.1.2. Volcano Authors (2024) Volcano: cloud native batch system. Note: https://volcano.sh/Accessed 2026-05-04 Cited by: §1, §2.2, §6.2. D. Weyns (2020) An introduction to self-adaptive systems: a contemporary software engineering perspective. Wiley-IEEE Press. Cited by: §1, §2.1, §2.2, §4.4, §6.3. M. Wilde, M. Hategan, J. M. Wozniak, B. Clifford, D. S. Katz, and I. Foster (2011) Swift: a language for distributed parallel scripting. Parallel Computing 37 (9), p. 633–652. Cited by: §2.2. Q. Wu, G. Bansal, J. Zhang, Y. Wu, et al. (2023) AutoGen: enabling next-gen LLM applications via multi-agent conversation. arXiv preprint arXiv:2308.08155. Cited by: item 1, §2.2, §2.5, §3.3. H. Xie, Z. Qin, G. Y. Li, and B. Juang (2021) Deep learning enabled semantic communication systems. IEEE Transactions on Signal Processing 69, p. 2663–2675. Cited by: §2.4, §2.6, §3.3, §6.4. Y. Xiong, Y. Sun, L. Xing, and Y. Huang (2018) Extend cloud to edge with KubeEdge. In IEEE/ACM Symposium on Edge Computing (SEC), p. 373–377. Note: See also https://kubeedge.io Cited by: §1, §2.2. M. Zaharia, A. Chen, A. Davidson, A. Ghodsi, S. A. Hong, A. Konwinski, S. Murching, T. Nykodym, P. Ogilvie, M. Parkhe, F. Xie, and C. Zumar (2018) Accelerating the machine learning lifecycle with MLflow. IEEE Data Engineering Bulletin 41 (4), p. 39–45. Cited by: §1, §2.2. M. Zhang, M. Abdi, V. R. Dasari, and F. Restuccia (2024) Semantic edge computing and semantic communications in 6G networks: a unifying survey and research challenges. arXiv preprint arXiv:2411.18199. Cited by: §2.4.

Instant research discovery