Distributed Intelligence in the Computing Continuum with Active Inference

Boris Sedlak; Karl Friston; Schahram Dustdar; Tommaso Salvatori; Victor Casamayor Pujol

REVIEW 4 major objections 5 minor 41 references

Distributed Intelligence in the Computing Continuum with Active Inference

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper claims that a decentralized set of Active Inference agents, one per service, can autonomously manage a distributed stream-processing pipeline so that device-aware Service Level Objectives (SLOiDs) are fulfilled most of the…

desk verdict A genuine multi-agent AIF extension with shipped code and data, but the headline 90% figure outruns a simulator that samples observations without temporal continuity. read the letter →

arxiv 2505.24618 v1 pith:TZ3O33EN submitted 2025-05-30 cs.DC cs.MAcs.SYeess.SY

Victor Casamayor Pujol , Boris Sedlak , Tommaso Salvatori , Karl Friston , Schahram Dustdar This is my paper

classification cs.DCcs.MAcs.SYeess.SY

keywords ComputingContinuumActiveInferenceServiceLevelObjectivesSLOiDmulti-agentsystemsstreamprocessingpipelineself-adaptiveservicesexpectedfreeenergy

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper is trying to establish that distributed intelligence in the Computing Continuum can be built from Active Inference agents, one per service, rather than a centralized controller. It introduces SLOiDs, service-level objectives that account for the hosting device's capabilities, and models each service agent as a factored partially observable Markov decision process that chooses elasticity actions (changing resolution or FPS, toggling a GPU, enabling or disabling communication) by minimizing expected free energy. In a simulated three-service video processing pipeline, the agents fulfill their SLOiDs over 90% of the time when transition models are given, and around 80% when the models are learned online, stabilizing within about 50 steps. A comparison with multi-agent reinforcement learning shows AIF agents reach comparable performance without millions of training steps, and both kinds of agents recover after the hosting device changes mid-run. If the result holds, decentralized service management could become practical on heterogeneous, resource-constrained devices without large training datasets.

What carries the argument

The load-bearing mechanism is the Active Inference agent defined as a factored POMDP over state modalities (SLOiDs plus system variables such as FPS, resolution, execution time, GPU state, and communication state), where actions are chosen by minimizing the expected free energy of candidate policies. Expected free energy splits into a pragmatic value term, which scores how likely a policy is to produce preferred outcomes encoded in the agent's log-probability preferences, and an information gain term, which scores how much a policy would reduce uncertainty about the hidden states. Because free energy is an additive quantity, if each agent minimizes its own expected free energy, the joint free energy of the whole ensemble is minimized as well, which is what licenses decentralized planning-as-inference. The transition model is either expert-defined through conditional probability tables on a dynamic Bayesian network or learned online starting from uniform distributions, and observations are assumed to be perfect so the likelihood mapping is an identity per modality.

What would settle it

Run the same three-agent controller on a physical or emulated continuum testbed with temporally correlated workloads, realistic network delays, and user-driven load changes, and compare agent-level SLOiD fulfillment over the same 200-step horizon; if online-learning fulfillment falls substantially below the reported ~80% or becomes unstable, the dataset-as-environment assumption is where the simulation diverged from deployment.

Watch

Extended reading notes

Core claim

The central claim is that a pipeline of interdependent streaming services in the Computing Continuum can be managed autonomously by one Active Inference agent per service, with no central coordinator. Each agent supervises its service by maintaining a generative model of the environment and continuously asking which action would both fulfill its preferred outcomes and reduce uncertainty about the world; this is operationalized as selecting policies that minimize expected free energy. The paper reports that with hand-specified conditional probability tables, the three agents achieve over 90% SLOiD fulfillment, and around 80% when those transition models are learned from interaction during deployment. It also reports that, unlike multi-agent reinforcement learning, which needs hundreds of thousands to tens of millions of training steps, AIF agents work effectively from the start, and that when the hosting hardware changes suddenly the agents detect the shift, temporarily raise their expected free energy, and then adapt their policies, with learning agents even deprioritizing a now-impossible energy objective in favor of achievable ones.

Load-bearing premise

The whole result rests on the assumption that the recorded dataset used as the simulation environment is a faithful proxy for real Computing Continuum dynamics, so that sampling an observation conditioned on the chosen action, without preserving any temporal sequence, captures how the actual system would respond.

Editorial extensions

If this is right

A distributed service pipeline can be supervised without a central orchestrator: one AIF agent per service, each minimizing its own expected free energy, keeps device-aware service objectives fulfilled most of the time.
When transition models are unknown, agents can still learn them during deployment and reach about 80% SLOiD fulfillment, stabilizing within roughly 50 time steps rather than needing offline training.
Multi-agent reinforcement learning matches AIF performance only after extensive training, whereas AIF agents are effective from the start, making them a candidate for deployments where training data or compute is scarce.
After an offloading event that changes the host's energy profile, AIF agents detect the shift and adapt, with learning agents able to reprioritize which SLOiDs to pursue.
Policy look-ahead length is not decisive for fulfillment in this near-memoryless simulation, but it strongly drives per-step computation, so short-horizon planning is the practical choice on constrained devices.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Because the simulator samples observations independently of time, a real deployment with autocorrelated load and hidden dependencies between devices could degrade the reported fulfillment rates; replaying the same policies over temporally ordered traces would quantify that gap.
The SLOiD encoding is reusable beyond video pipelines: any device-aware objective that can be discretized (energy budgets, thermal limits, latency caps, privacy constraints) can be expressed as preferred outcomes in an agent's POMDP.
The large online-learning slowdown hints that practical edge deployments will need hierarchical control or amortized inference; the paper mentions such hybrid strategies as future work but does not evaluate them.
Sharing learned transition models between agents on similar hardware, which the paper flags as model-transfer future work, would likely close much of the gap between the 90% and 80% fulfillment regimes.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Bottom line: this is a real extension of the Sedlak line—one AIF agent per service instead of a single controller—and the authors ship code, data, and an honest MARL baseline. But the headline 90% figure is not backed by the evidence as stated, and the paper's own Section 4.2.3 tells you why: observations are sampled i.i.d. from a dataset, with no temporal continuity. That makes the central "adaptation over time" claim largely untested against real continuum dynamics.

What's actually new: a factored POMDP template for three cooperating services (Producer/Worker/Consumer), with SLOiD as a device-aware reframing of SLO. The learning-vs-expert comparison is useful, and the data-efficiency contrast with PPO (400K vs 40M steps) is a fair point even if not a head-to-head benchmark. The offloading experiment is a nice idea, and the learning agent's behavior there is the most interesting result in the paper.

Where it's soft: first, the over-90% statement in the abstract sits uneasily with the Worker's visibly lower fulfillment in Figure 6; there are no per-agent error bars for the 10 runs. Second, the expert transition models are hand-specified CPTs that mirror the simulator's own structure and are never validated on held-out traces, so the expert-model success is close to a self-consistency check. Third, the i.i.d. sampling means policy length and temporal reasoning are nearly irrelevant—the authors concede this in Section 5.5. The learning case (around 80%) is the more credible number, and even that is measured in the same static environment. None of this is fatal; the paper is careful about its limitations, more than most. But the abstract overstates what the simulation can support.

Who this is for: researchers working on autonomic service management or applying active inference to systems problems. The POMDP design is reusable, the dataset is public, and the paper gives a clear template. A serious referee should engage with it; the fixes are concrete—per-agent statistics, reconcile the abstract, validate or soften the CPT claims, or reframe the contribution as a modeling template rather than a demonstrated adaptation mechanism.

My recommendation: conditional accept toward a workshop or systems venue, with the temporal-continuity issue addressed by a replay-based experiment or by toning down the claims. It deserves peer review.

Referee Report

4 major / 5 minor

Summary. The paper proposes a distributed stream-processing pipeline in the Computing Continuum in which each service is supervised by an Active Inference (AIF) agent. The authors define device-aware Service Level Objectives (SLOiDs), specify POMDP-based generative models for a Producer–Worker–Consumer pipeline, and evaluate the agents in five simulation experiments: expert-model SLOiD fulfillment, online learning of the transition model, comparison with multi-agent PPO, adaptation to a sudden hardware change (offloading), and computing cost. The central empirical claim is that AIF agents achieve more than 90% SLOiD fulfillment with tested transition models and roughly 80% when learning the models during deployment, with substantially lower training cost than MARL.

Significance. If the central claim holds, the paper would provide a credible template for decentralized, model-based service management in heterogeneous computing continuum systems, with the notable strengths of publicly available code and dataset, reproducible experiments, and an honest comparison against a standard MARL baseline (PPO). The introduction of SLOiDs as device-aware objectives is a useful conceptual contribution. However, the significance is currently conditional on the simulation environment being a faithful proxy for real continuum dynamics, and on the reported fulfillment numbers being statistically supported; both conditions are only partially met in the present manuscript.

major comments (4)

[Section 4.2.3 and Section 5.5] The environment is not a temporal process: Section 4.2.3 states that each new observation is sampled from the dataset and 'this sample need not follow a temporal sequence,' and Section 5.5 concedes that the environment has 'limited temporal dependencies' because 'new states are sampled to fulfill constraints without necessarily maintaining temporal continuity.' Under this protocol, the environment is an action-conditioned bag of independent samples, so the paper's claims about multi-step planning (policy length), adaptation after offloading, and recovery after environmental change are not demonstrated for real continuum workloads, which exhibit autocorrelated load, network delay, and device-state persistence. This is load-bearing for the abstract's central claim, and it needs to be addressed by either replaying the dataset in chronological order, introducing a temporally correlated environment, or clearly restricting the claims to the i.i.d. sampling regime.
[Abstract and Figures 6 and 7] The abstract's 'over 90% SLOiD fulfillment' statement conflicts with the visible results: in Figure 6 the Worker's fulfillment curves for Latency and W-consumption stabilize well below 0.9 (approximately 0.7–0.8), and the text itself notes that the 'Worker agent clearly struggles.' The aggregate statement may average over three agents, but as written it overstates the per-agent performance. Please report per-agent aggregate values with standard deviations or confidence intervals, and qualify the abstract's claim (e.g., 'most agents' or 'on average').
[Section 4.2.3 and Section 5.5] No per-repetition statistics are reported for the ten runs. The text claims that one experiment yielded 'consistently higher' fulfillment for policy length 1 (Section 5.5) and that the Worker exhibits 'greater performance variance' (Section 5.1), but no standard deviations, confidence intervals, or statistical tests are supplied. Given that the environment samples stochastically and that only ten repetitions were run, statements of consistency and relative performance (including the MARL comparison) are not yet supported; please add error bars or per-run summaries and, where relevant, a paired test or effect-size measure.
[Section 4.1 and Appendices A–C] The expert transition models are hand-specified rules that mirror the simulator's own causal structure (the same DBN structure is also fixed for the learned models, with only CPT parameters learned). Evaluating these expert models on a dataset generated by independently adjusting the same parameters is close to validating a model against a generator built from the same rules; the >90% figure may therefore reflect a near-tautological match rather than robust model-based control. I recommend adding a validation against held-out portions of the dataset or against a differently generated trace, and at minimum discussing this potential circularity explicitly.

minor comments (5)

[Section 4.1.1] The heading 'Preferred Ouctomes (C)' contains a typo; it should be 'Preferred Outcomes (C)'.
[Section 4.1.2] The preferred outcome vector for W-consumption is written as {3, 2.5, 0, 5}, but W-consumption has three levels (LOW, MID, HIGH); the vector should have three entries (e.g., {3, 2.5, 0}), and the current four-entry vector is inconsistent with the state definition.
[Section 4.3.1] 'state-off-the-art' should be 'state-of-the-art' in the description of the MARL comparison.
[Section 8] The conclusion says learning agents achieved rates 'approximately 10% lower' than expert-model agents; since the abstract expresses the same difference as 'over 90%' versus 'around 80%', please state whether this is 10 percentage points or 10% relative, and align the wording.
[References] The reference Zahidi et al. (2024) contains 'n/a, n/a' in the volume and issue fields; please complete the bibliographic details.

Circularity Check

0 steps flagged · score 2.0 of 10

No circular reduction is present: the SLOiD figures are closed-loop simulation results with hand-specified or online-learned models, and the main weaknesses are external-validity threats from the i.i.d. sampling protocol rather than equation-level circularity.

full rationale

Walking the derivation chain: expected free energy (Eq. 1) is minimized with the standard pymdp machinery, and the preferred outcomes C are set to the SLOiD criteria, so the objective is aligned with the metric; this is a design choice, not a tautology, because the Worker's competing W-consumption and Latency preferences prevent guaranteed fulfillment and the paper reports lower and more variable Worker performance. The expert transition models are explicitly specified rule-based CPTs in Appendices A-C and are not fitted to the fulfillment numbers; the environment samples observations from an external recorded dataset (Sections 4.2.2 and 4.2.3), so the reported >90% SLOiD fulfillment is a genuine closed-loop outcome for that simulator, not a fitted parameter renamed as a prediction. The learned-model experiments fix the DBN structure and only learn CPT parameters within it, which limits the meaning of 'learning the models during deployment' but is disclosed in Section 4.1.1. The self-citations (e.g., Sedlak et al. 2024a for equilibrium and Markov blankets) are minor and not load-bearing: the equilibrium definition is given locally in Section 2.1, and the DBN structures are fully drawn in Figures 3-5 with the CPTs in the appendices. The most significant concerns are validity threats rather than circularity: Section 4.2.3 states that each new observation 'need not follow a temporal sequence,' and Section 5.5 concedes that 'new states are sampled to fulfill constraints without necessarily maintaining temporal continuity,' so the environment is a near-memoryless action-conditioned sampler rather than a temporally correlated continuum workload; this weakens the transferability of the adaptation claims to real deployment but does not make any derivation reduce to its own inputs. Therefore the circularity score is 2 for a minor non-load-bearing self-reference, with no circular step identified.

Assumptions & free parameters 3 free parameters · 5 assumptions · 1 invented entities

The central claim rests on hand-set preferences, hand-chosen discretization, a fixed DBN structure, and expert CPTs that are not validated independently. These are not fitted to the fulfillment numbers in a formal sense, but they are author choices that shape the reported success rates.

free parameters (3)

Preference vectors C (log preferred outcomes) = C_WF={0.25,1.5,0.25}; C_Latency={0.1,3}; C_W-consumption={3,2.5,0,5} (likely a typo)
Hand-set in Section 4.1; they define which SLOiD states are preferred and control the trade-off between competing objectives such as latency versus energy.
Discretization thresholds for continuous service metrics = Time bins 5 levels, W-consumption 3 levels, Smoothness 5 levels; thresholds in Sections 4.1.2 and 4.1.3
Chosen by the authors. The bin edges determine what is counted as SLOiD fulfillment, so they are consequential hand choices.
Policy length (planning horizon) = pl=3 in main experiments; pl=1 in the cost comparison
Set as an experimental parameter in Section 4.3.1 and Section 5.5. It strongly affects compute time and, the paper admits, partly affects the EFE comparison.

assumptions (5)

domain assumption Perfect sensing: observations equal states, so the likelihood matrix A is the identity
Stated in Section 2.2 and used for all agents in Section 4.1. This removes the partial observability that motivates POMDPs and may fail when hidden user intentions or remote service states matter.
domain assumption The environment is action-conditioned and largely memoryless: each new observation is sampled from the dataset and need not follow a temporal sequence
Section 4.2.3, simulation step 4. This assumes real continuum dynamics are captured by the recorded action-conditional samples, without temporal autocorrelation or unrecorded couplings.
ad hoc to paper The DBN structure for learned models is fixed by the authors; only the CPT parameters are learned
Section 4.1.1 states that when the agent learns the transition parameters, the CPTs are initialized uniformly but the DBN structure remains identical to the expert model. The paper therefore does not learn model topology.
ad hoc to paper The expert-defined CPTs in Appendices A to C are valid models of the real pipeline
These deterministic rules are used to obtain the over-90 percent result in Section 5.1, but they are not validated against held-out data or against the recorded traces' actual transition frequencies.
domain assumption Communication between services is fully captured by binary Toggle comm channels plus the Producer's assumed compliance
In Appendices B and C, several SLOiD transitions are made to depend on enabling or disabling the upstream communication channel, assuming the Producer will honor requests. Real cross-service coordination may involve richer negotiation.

invented entities (1)

SLOiD (Service Level Objective in Device)
purpose: A device-aware SLO used to define each agent's preferred outcomes and the fulfillment criteria for the pipeline
Introduced in this paper as a term and measurement concept; no external standard, benchmark, or independent validation is provided, so it functions as a conceptual ledger entry rather than an empirically grounded entity.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Distributed Intelligence in the Computing Continuum with Active Inference." pith.science (2026). https://pith.science/paper/TZ3O33EN

@misc{pith2026250524618,
  author       = {Pith},
  title        = {Pith review of: Distributed Intelligence in the Computing Continuum with Active Inference},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/TZ3O33EN}},
  note         = {Machine review of arXiv:2505.24618}
}

read the original abstract

The Computing Continuum (CC) is an emerging Internet-based computing paradigm that spans from local Internet of Things sensors and constrained edge devices to large-scale cloud data centers. Its goal is to orchestrate a vast array of diverse and distributed computing resources to support the next generation of Internet-based applications. However, the distributed, heterogeneous, and dynamic nature of CC platforms demands distributed intelligence for adaptive and resilient service management. This article introduces a distributed stream processing pipeline as a CC use case, where each service is managed by an Active Inference (AIF) agent. These agents collaborate to fulfill service needs specified by SLOiDs, a term we introduce to denote Service Level Objectives that are aware of its deployed devices, meaning that non-functional requirements must consider the characteristics of the hosting device. We demonstrate how AIF agents can be modeled and deployed alongside distributed services to manage them autonomously. Our experiments show that AIF agents achieve over 90% SLOiD fulfillment when using tested transition models, and around 80% when learning the models during deployment. We compare their performance to a multi-agent reinforcement learning algorithm, finding that while both approaches yield similar results, MARL requires extensive training, whereas AIF agents can operate effectively from the start. Additionally, we evaluate the behavior of AIF agents in offloading scenarios, observing a strong capacity for adaptation. Finally, we outline key research directions to advance AIF integration in CC platforms.

Figures

Figures reproduced from arXiv: 2505.24618 by the authors.

**Figure 1.** High-level vision of distributed intelligence in computing continuum systems; each processing service is supervised by [PITH_FULL_IMAGE:figures/full_fig_p007_1.png] view at source ↗

**Figure 2.** Smart city service pipeline from data producer to consumer. The [PITH_FULL_IMAGE:figures/full_fig_p007_2.png] view at source ↗

**Figure 3.** Producer ’s DBN. The model includes five modalities, two of which behave identically and are therefore grouped together in the figure. The colors correspond to the services each modality is associated with. Actions (U) The Producer ’s action set (U) consists of two actions, each with three possible values. 1. Change FPS: Increase, Stay, and Decrease the FPS current value. 2. Change resolution: Increase, Stay, and De… view at source ↗

Figures from the paper (7 more)

**Figure 4.** Figure 4: Worker ’s DBN. The model includes six modalities, two of which are SLOiDs. The colors correspond to the services each modality is associated with. Actions (U) The Worker’s action set (U) consist of two actions: 1. Switch GPU: Switch off and Switch on modifies the GPU c…

**Figure 5.** Figure 5: Consumer ’s DBN. The model includes six modalities, three of which are SLOiDs. The colors correspond to the services each modality is associated with. Actions (U) The Consumer action set (U) consist of: 1. Toggle comm: Enable and Disable the upstream communication chan…

**Figure 6.** Figure 6: SLOiDs fulfillment rate with no B parameter learning and policy length of 3. 5.2 Learning the transition model [PITH_FULL_IMAGE:figures/full_fig_p013_6.png]

**Figure 7.** Figure 7: shows the SLOiD fulfillment rate for each AIF agent in a variation of the previous experiment where agents must select actions to fulfill SLOiDs while simultaneously learning the transition model. In comparison with the results from the previous experiment ( [PITH_FUL…

**Figure 8.** Figure 8: MARL simulation, showing the SLOiD fulfillment rates for the minimally- and well-trained agents [PITH_FULL_IMAGE:figures/full_fig_p014_8.png]

**Figure 9.** Figure 9: AIF Worker agent suffering an offloading to a new and different host after 75 time steps controlling its SLOiDs. results in a slowdown of approximately 69.08×. Interestingly, this computational burden diminishes with shorter policy horizons due to the reduced combinat…

**Figure 10.** Figure 10: SLOiDs fulfillment rate with B parameter learning and policy length of 1. 4Although longer policies generally achieve lower EFE values, this effect is partly an artifact of EFE computation: longer policies distribute cumulative EFE over more steps, which lowers the av…

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

41 extracted references · 36 canonical work pages

[1]

If Change FPSt = Stay, the state remains unchanged: WFt+1 = WFt

work page
[2]

The state also remains unchanged if boundary conditions for FPS prevent the action’s effect: i.e., if Change FPSt = Increase and FPSt is already the highest value, or if Change FPSt = Decrease and FPSt is already the lowest value

work page
[3]

• If WFt = Increase, then WFt+1 = Stay

If Change FPSt = Increase (and FPS is not maximum): • If WFt = Decrease or WFt = Stay, then WFt+1 = Decrease. • If WFt = Increase, then WFt+1 = Stay. Distributed Intelligence in the CC with AIF Casamayor Pujol et al

work page
[4]

• If WFt = Decrease, then WFt+1 = Stay

If Change FPSt = Decrease (and FPS is not minimum): • If WFt = Increase or WFt = Stay, then WFt+1 = Increase. • If WFt = Decrease, then WFt+1 = Stay. Note that these rules simplify the dependency on the FPS state, using it only to check boundary conditions. The precise dynamics might vary with specific hardware configurations in practice, but this expert ...

work page
[5]

Share Info Modality The transition P (ShareInfot+1|ShareInfot, Toggle Commt) depends on the current state and the action on the upstream communication channel

If both modalities’ states remain unchanged, W-consumption remains the same: W-consumptiont+1 = W-consumptiont. Share Info Modality The transition P (ShareInfot+1|ShareInfot, Toggle Commt) depends on the current state and the action on the upstream communication channel. The CPT rules are:

work page
[12]

If the action ( Change FPS or Change Resolution) is Stay, the value remains unchanged at t + 1

work page
[13]

If the action is Increase, the value at t + 1transitions to the next higher discrete level defined for the modality, unless the value at t is already the maximum, in which case it remains unchanged

work page
[14]

If the action is Decrease, the value at t + 1transitions to the next lower discrete level, unless the value at t is already the minimum, in which case it remains unchanged. B Worker’s transition model Latency Modality The transition P (Latencyt+1|Latencyt, Toggle Commt) is simplified to depend only on the cur- rent state Latencyt and the action taken on t...

work page

Show all 41 references

[15]

If Toggle Commt = Enable, the state transitions to or remains True: Latencyt+1 = True
[16]

This simplification assumes controlling the communication channel fully dictates this SLO status in our model

If Toggle Commt = Disable, the state remains unchanged: Latencyt+1 = Latencyt. This simplification assumes controlling the communication channel fully dictates this SLO status in our model. All state modalities affected by the action Toggle Comm assume that the Producer agent ...
[17]

Then, the Execution Time remains unchanged (ExecTimet+1 = ExecTimet)

If Switch GPUt = Stay, or if Switch GPUt = Switch off when GPUt = Off, or if Switch GPUt = Switch on when GPUt = On. Then, the Execution Time remains unchanged (ExecTimet+1 = ExecTimet)
[18]

If ExecTimet is already the lowest value, it remains unchanged

If the GPU is on (i.e., Switch GPUt = Switch on and GPUt = Off, leading to GPUt+1 = On), the Execution Time decreases by one discrete step ( ExecTimet+1 = prev(ExecTimet)). If ExecTimet is already the lowest value, it remains unchanged
[19]

If ExecTimet is already the highest value, it remains unchanged

If the GPU is off (i.e., Switch GPUt = Switch off and GPUt = On, leading to GPUt+1 = Off), the Execution Time increases by one discrete step ( ExecTimet+1 = next(ExecTimet)). If ExecTimet is already the highest value, it remains unchanged. FPS Modality The transition P (FPSt+1...
[20]

If communication is disabled or unchanged ( Toggle Commt = (Disable or Stay)), the FPS remains the same: FPSt+1 = FPSt
[21]

If FPSt is already the lowest value, it remains unchanged

If communication is enabled ( Toggle Commt = Enable), the FPS decreases by one discrete step: FPSt+1 = prev(FPSt). If FPSt is already the lowest value, it remains unchanged. 5Latency also depends on the Execution Time and the FPS, however, here we focus on the communication ac...
[22]

If both Share Information and GPU are activated (transition to or stay True), W-consumption increases by one step: W-consumptiont+1 = next(W-consumptiont)
[23]

If one modality ( ShareInfo or GPU) is activated while the other’s state remains unchanged,W-consumption increases by one step: W-consumptiont+1 = next(W-consumptiont)
[24]

If either modality is deactivated (transitions to or stays False), W-consumption decreases by one step: W-consumptiont+1 = prev(W-consumptiont)
[25]

If one modality is activated and the other is deactivated within the same time step, W-consumption remains the same: W-consumptiont+1 = W-consumptiont
[27]

If the action is Disable, the state becomes False: ShareInfot+1 = False
[28]

If the action is Enable, the state becomes True: ShareInfot+1 = True
[29]

GPU Modality The transition P (GPUt+1|GPUt, Switch GPUt) depends on the current state and the action applied to the GPU

If the action is Stay, the state remains unchanged: ShareInfot+1 = ShareInfot. GPU Modality The transition P (GPUt+1|GPUt, Switch GPUt) depends on the current state and the action applied to the GPU. The CPT rules mirror those for Share Info, using actions Switch on, Switch of...
[30]

If Switch GPUt = Switch off, then GPUt+1 = False
[31]

If Switch GPUt = Switch on, then GPUt+1 = True
[32]

If Switch GPUt = Stay, then GPUt+1 = GPUt. C Consumer’s transition model Success Modality The transition P (Successt+1|Successt, Resolutiont, Toggle Commt) depends on the current Suc- cess state, the Resolution, and the upstream communication action. The CPT is defined by the ...
[33]

If Toggle Commt is Enable, the state transitions to or remains True: Successt+1 = True
[34]

Smoothness Modality The transition P (Smoothnesst+1|Smoothnesst, FPSt, Toggle Commt) depends on the cur- rent Smoothness state, the FPS state, and the upstream communication action

If Toggle Commt is Disable or Stay, the state remains unchanged: Successt+1 = Successt. Smoothness Modality The transition P (Smoothnesst+1|Smoothnesst, FPSt, Toggle Commt) depends on the cur- rent Smoothness state, the FPS state, and the upstream communication action. The CPT...
[35]

If Toggle Commt is Disable or Stay, the state remains unchanged: Smoothnesst+1 = Smoothnesst
[36]

If Toggle Commt is Enable: the resulting state Smoothnesst+1 becomes True, reflecting the expectation that enabling communication aims to improve this SLO, potentially by facilitating an FPS increase. C-consumption Modality The transition P (C-consumptiont+1|C-consumptiont, Sh...
[37]

If Toggle Commt = Enable causes Share Informationto switch fromFalse to True (e.g., ShareInfot = False), then C-consumption increases: C-consumptiont+1 = next(C-consumptiont)
[38]

If the action Toggle Commt = Disable causes Share Information to switch from True to False (e.g., ShareInfot = True), then C-consumption decreases: C-consumptiont+1 = prev(C-consumptiont)
[39]

Distributed Intelligence in the CC with AIF Casamayor Pujol et al

In all other cases, C-consumption remains unchanged: C-consumptiont+1 = C-consumptiont. Distributed Intelligence in the CC with AIF Casamayor Pujol et al. FPS and Resolution Modalities The transitions P (FPSt+1|FPSt, Toggle Commt) and P (Resolutiont+1|Resolutiont, Toggle Commt...
[40]

If Toggle Commt is Disable or Stay, the respective modality’s value remains unchanged ( FPSt+1 = FPSt, Resolutiont+1 = Resolutiont)
[41]

Share Information Modality The transition probabilities P (ShareInfot+1|ShareInfot, Toggle Commt) are defined identically to the corresponding modality in the Worker agent model

If Toggle Commt is Enable, both the FPS and Resolution values increase by one discrete step, if possible (i.e., FPSt+1 = next(FPSt), Resolutiont+1 = next(Resolutiont)), subject to saturation at their maximum values. Share Information Modality The transition probabilities P (Sh...
[2017]

https://doi.org/10.48550/arXiv.1707.06347 arXiv:1707.06347 [cs]

Proximal Policy Optimization Algorithms. https://doi.org/10.48550/arXiv.1707.06347 arXiv:1707.06347 [cs]. [Sedlak et al.(2024a)] Boris Sedlak, Victor Casamayor Pujol, Praveen Kumar Donta, and Schahram Dustdar. 2024a. Equilibrium in the Computing Continuum through Active Infere...

2024 doi arXiv
[2018]

In 2018 14th International Conference on Net- work and Service Management (CNSM)

Elastic Services for Edge Computing. In 2018 14th International Conference on Net- work and Service Management (CNSM) . 358–362. https://ieeexplore.ieee.org/abstract/ document/8584964?casa_token=39ojZ7iLIZEAAAAA:abK3nEI9LXbzy4GFAFGop2IytWTSZup_ qrLa5It5LCaoh6dOfJvlu-qWzeJ2TXUl...

2022
[2019]

In Artificial Intelligence for the Internet of Everything

Active Inference in Multiagent Systems: Context-Driven Collaboration and Decentralized Purpose-Driven Team Adaptation. In Artificial Intelligence for the Internet of Everything. Academic Press, Online. [Liang et al.(2018)] Eric Liang, Richard Liaw, Robert Nishihara, Philipp Mo...

2018 arXiv
[2020]

IEEE Transactions on Wireless Communications19, 2 (Feb

Edge and Central Cloud Computing: A Perfect Pairing for High Energy Efficiency and Low-Latency. IEEE Transactions on Wireless Communications19, 2 (Feb. 2020), 1070–1083. https://doi.org/10.1109/ TWC.2019.2950632 [Kirchhoff et al.(2018)] Michael Kirchhoff, Thomas Parr, Ensor Pa...

2018
[2021]

In Conference on Neu- ral Information Processing Systems (NeurIPS)

RLlib Flow: Distributed Reinforcement Learning is a Dataflow Problem. In Conference on Neu- ral Information Processing Systems (NeurIPS) . https://proceedings.neurips.cc/paper/2021/file/ 2bce32ed409f5ebcee2a7b417ad9beed-Paper.pdf [Zafeiropoulos et al.(2024)] Anastasios Zafeiro...

2024
[2024]

IEEE Communications Magazine (2024)

AI-Assisted Synergetic Orchestration Mechanisms for Autoscaling in Computing Continuum Systems. IEEE Communications Magazine (2024). https://doi.org/10.1109/MCOM.001.2200583 [Zahidi et al.(2024)] Usman A. Zahidi, Arshad Khan, Tsvetan Zhivkov, Johann Dichtl, Dom Li, Soran Parsa...

2024
[3854]

https://doi.org/10.1109/TMC.2022.3147800 [Hu et al.(2020)] Xiaoyan Hu, Lifeng Wang, Kai-Kit Wong, Meixia Tao, Yangyang Zhang, and Zhongbin Zheng

2020

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [1]

If Change FPSt = Stay, the state remains unchanged: WFt+1 = WFt

work page

[2] [2]

The state also remains unchanged if boundary conditions for FPS prevent the action’s effect: i.e., if Change FPSt = Increase and FPSt is already the highest value, or if Change FPSt = Decrease and FPSt is already the lowest value

work page

[3] [3]

• If WFt = Increase, then WFt+1 = Stay

If Change FPSt = Increase (and FPS is not maximum): • If WFt = Decrease or WFt = Stay, then WFt+1 = Decrease. • If WFt = Increase, then WFt+1 = Stay. Distributed Intelligence in the CC with AIF Casamayor Pujol et al

work page

[4] [4]

• If WFt = Decrease, then WFt+1 = Stay

If Change FPSt = Decrease (and FPS is not minimum): • If WFt = Increase or WFt = Stay, then WFt+1 = Increase. • If WFt = Decrease, then WFt+1 = Stay. Note that these rules simplify the dependency on the FPS state, using it only to check boundary conditions. The precise dynamics might vary with specific hardware configurations in practice, but this expert ...

work page

[5] [5]

Share Info Modality The transition P (ShareInfot+1|ShareInfot, Toggle Commt) depends on the current state and the action on the upstream communication channel

If both modalities’ states remain unchanged, W-consumption remains the same: W-consumptiont+1 = W-consumptiont. Share Info Modality The transition P (ShareInfot+1|ShareInfot, Toggle Commt) depends on the current state and the action on the upstream communication channel. The CPT rules are:

work page

[6] [12]

If the action ( Change FPS or Change Resolution) is Stay, the value remains unchanged at t + 1

work page

[7] [13]

If the action is Increase, the value at t + 1transitions to the next higher discrete level defined for the modality, unless the value at t is already the maximum, in which case it remains unchanged

work page

[8] [14]

If the action is Decrease, the value at t + 1transitions to the next lower discrete level, unless the value at t is already the minimum, in which case it remains unchanged. B Worker’s transition model Latency Modality The transition P (Latencyt+1|Latencyt, Toggle Commt) is simplified to depend only on the cur- rent state Latencyt and the action taken on t...

work page