# distributed algorithm

An algorithm for designing, implementing, and analyzing systems in which processes communicate and coordinate across a distributed network.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Byzantine Resilience of Robot Gathering under Round-Robin Scheduling

DevFeed: [Byzantine Resilience of Robot Gathering under Round-Robin Scheduling](<https://devfeed.tech/articles/byzantine-resilience-of-robot-gathering-under-round-robin-scheduling-140389.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.22631>)

Author: Fabian Frei, Yuichi Sudo, Koichi Wada

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [round robin](<https://devfeed.tech/topics/round-robin.md>), [Resilience](<https://devfeed.tech/topics/resilience.md>)

Tags: [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [gathering](<https://devfeed.tech/tags/gathering.md>), [resilience](<https://devfeed.tech/tags/resilience.md>), [robot](<https://devfeed.tech/tags/robot.md>), [round-robin](<https://devfeed.tech/tags/round-robin.md>), [scheduling](<https://devfeed.tech/tags/scheduling.md>)

### AI overview

For deterministic gathering of anonymous, oblivious robots under round-robin scheduling, ToMax guarantees that all correct robots gather permanently when the number of Byzantine robots f is at most ⌊√n/2⌋. Each robot moves to a position with maximum multiplicity and stays put only when its current position is the unique maximum. The result assumes rigid movement and allows local coordinate systems to change adversarially between activations; it establishes an Ω(√n) lower bound on achievable Byzantine resilience.

### Source excerpt

arXiv:2611.22631v1 Announce Type: new Abstract: We study deterministic gathering of $n$ anonymous, oblivious mobile robots in the plane under round-robin scheduling with rigid movement, in the presence of $f$ Byzantine robots. Robots observe all robot positions with their multiplicities, while their local coordinate systems may change adversarially between activations. The goal is for all correct robots to gather at a single point in finite time and remain there forever. We analyze ToMax, a simple algorithm that moves to a point of maximum multiplicity and stays still if and only if its current position is the unique maximum. We prove that ToMax achieves gathering whenever $f\le\lfloor\sqrt{n}/2\rfloor$, establishing an $\Omega(\sqrt{n})$ lower bound on the achievable Byzantine resilience.

## AInfer-PD: Communication-Safe In-Place Prefill-Decode Multiplexing for Distributed MoE Rollouts

DevFeed: [AInfer-PD: Communication-Safe In-Place Prefill-Decode Multiplexing for Distributed MoE Rollouts](<https://devfeed.tech/articles/ainfer-pd-communication-safe-in-place-prefill-decode-multiplexing-for-distributed-moe-rollouts-140376.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2609.00993>)

Author: Guowei Wang, Chaokun Yang, Zhenxuan Pan, Yipeng Wei, Yuhong Guo, Minghua Zhu, Zechuan Zhang, Shuo Wan, Xiaowei Zhu

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [async](<https://devfeed.tech/topics/async.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>)

Tags: [ablation](<https://devfeed.tech/tags/ablation.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [batches](<https://devfeed.tech/tags/batches.md>), [collective](<https://devfeed.tech/tags/collective.md>), [communication](<https://devfeed.tech/tags/communication.md>), [completion](<https://devfeed.tech/tags/completion.md>), [continuation](<https://devfeed.tech/tags/continuation.md>), [cross](<https://devfeed.tech/tags/cross.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [d](<https://devfeed.tech/tags/d.md>), [decode](<https://devfeed.tech/tags/decode.md>), [deepep](<https://devfeed.tech/tags/deepep.md>), [devices](<https://devfeed.tech/tags/devices.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [engine](<https://devfeed.tech/tags/engine.md>), [moe](<https://devfeed.tech/tags/moe.md>), [multiplexing](<https://devfeed.tech/tags/multiplexing.md>), [pd](<https://devfeed.tech/tags/pd.md>), [prefill](<https://devfeed.tech/tags/prefill.md>), [safe](<https://devfeed.tech/tags/safe.md>)

### AI overview

AInfer-PD lets decode iterations progress during long prefills in distributed MoE rollouts by coordinating collective ordering across ranks at safe communication boundaries and separating prefill and decode communication buffers and protocol state within one DeepEP runtime. This allows prefills to use DeepEP's normal path while decode keeps its low-latency path, with model weights and KV storage shared on the same devices. In reported prefill-intensive workloads, fixed-workload completion time fell 7.1-22.5% versus the same AInfer engine without P/D multiplexing and 24.8-32.9% versus SGLang on one node; on two nodes, reductions were 18.0-35.3% and 18.3-31.8%, respectively. A same-engine ablation found fine-grained boundaries improved completion time by a further 8.6-19.8% over whole-prefill asynchronous enqueue.

### Source excerpt

arXiv:2609.00993v3 Announce Type: replace Abstract: In agentic reinforcement learning (RL), asynchronous multi-turn trajectories repeatedly introduce continuation prefills (P) while other trajectories remain in decode (D). Efficient rollout completion therefore requires D to advance during long P executions. In-place multiplexing shares devices, model weights, and KV state, but phase-specific communication in distributed MoE introduces two constraints: cross-rank collective ordering and ownership of mutable communication state. Whole-prefill coordination can ensure safe ordering but delays D. DeepEP's normal and low-latency paths suit large P and small D batches, respectively, but safely overlapping them requires separating their mutable communication state. We present AInfer-PD, which extends in-place P/D multiplexing to distributed MoE rollouts. AInfer-PD establishes rank-consistent collective ordering at safe communication boundaries, allowing successive D iterations to advance without waiting for an entire prefill execution to be enqueued or completed. It gives P and D separate communication buffers and protocol state within one DeepEP runtime, allowing P to use the normal path while D retains the low-latency path. Together, these mechanisms preserve useful P/D overlap while sharing model weights and KV storage on the same devices. Across repeated single-node prefill-intensive workloads, AInfer-PD reduces fixed-workload rollout completion time by 7.1-22.5% relative to the same AInfer engine with P/D multiplexing disabled and by 24.8-32.9% relative to SGLang. On two nodes, the reductions are 18.0-35.3% and 18.3-31.8%, respectively. In a same-engine ablation, fine-grained boundaries reduce completion time by a further 8.6-19.8% over whole-prefill asynchronous enqueue.

## Network-Native DNN Architecture Synthesis for Distributed Inference

DevFeed: [Network-Native DNN Architecture Synthesis for Distributed Inference](<https://devfeed.tech/articles/network-native-dnn-architecture-synthesis-for-distributed-inference-136993.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.20824>)

Author: Fan Yang, Xiaolong Wu, Qi Cao, Fen Hou, Yulin Shao

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [model architecture](<https://devfeed.tech/topics/model-architecture.md>), [Deep neural networks](<https://devfeed.tech/topics/deep-neural-networks.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [capacity](<https://devfeed.tech/tags/capacity.md>), [communication](<https://devfeed.tech/tags/communication.md>), [compute](<https://devfeed.tech/tags/compute.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-it](<https://devfeed.tech/tags/cs-it.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-inference](<https://devfeed.tech/tags/distributed-inference.md>), [dnn](<https://devfeed.tech/tags/dnn.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [inference](<https://devfeed.tech/tags/inference.md>), [latency](<https://devfeed.tech/tags/latency.md>), [linear](<https://devfeed.tech/tags/linear.md>), [linear-programming](<https://devfeed.tech/tags/linear-programming.md>), [math-it](<https://devfeed.tech/tags/math-it.md>), [model](<https://devfeed.tech/tags/model.md>), [native](<https://devfeed.tech/tags/native.md>), [network](<https://devfeed.tech/tags/network.md>), [networks](<https://devfeed.tech/tags/networks.md>), [neural-network](<https://devfeed.tech/tags/neural-network.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [synthesis](<https://devfeed.tech/tags/synthesis.md>)

### AI overview

The paper proposes designing distributed DNN architectures around a physical network's topology, which defines dependencies between nodes; computation is allocated subject to communication, compute, storage, synchronization, and latency constraints. Its LP-based Architecture Synthesis (LPAS) algorithm produces feasible architectures with a computable suboptimality bound. In experiments, LPAS had relative gaps below 0.6% to an LP-derived upper bound and ran substantially faster than direct mixed-integer LP optimization on larger networks. Under matched deadlines, network-native models used more compute nodes and model-storage capacity than model-first deployments; after training, they achieved higher classification accuracy across evaluated dataset-precision settings, with average gains up to 10.69%.

### Source excerpt

arXiv:2611.20824v1 Announce Type: cross Abstract: Distributed deep neural network (DNN) inference typically follows a model-first paradigm, in which a predefined DNN is partitioned and deployed over a physical network. On irregular communication-computation topologies, however, this approach can create transmission bottlenecks and leave distributed resources underutilized. This paper reverses this perspective and asks: given a physical network, what kind of DNN can it naturally support? To answer this question, we propose a network-native DNN architecture synthesis paradigm in which the physical network topology directly defines inter-node neural dependencies. Neural computation is allocated across nodes under communication, computation, storage, synchronization, and latency constraints. We establish structural properties of the synthesis problem and develop linear programming (LP)-based Architecture Synthesis (LPAS), an efficient topology-guided algorithm that produces a feasible architecture with a computable bound on suboptimality. Experiments on physical networks of different sizes show that LPAS achieves relative gaps below 0.6% to the LP-derived upper bound, with substantially lower runtime than direct mixed-integer LP optimization on larger networks. Under matched network deadlines, the network-native architectures activate more compute nodes and utilize a larger proportion of available model-storage capacity than the model-first baseline. After training, the network-native models achieve higher classification accuracy across all evaluated dataset-precision settings, with the average gain of up to 10.69%. This network-native design paradigm thus turns the physical network from a deployment constraint into an architecture design primitive.

## Sustaining In-Network Computation in Satellite Networks: An Architecture for Semantic Continuity

DevFeed: [Sustaining In-Network Computation in Satellite Networks: An Architecture for Semantic Continuity](<https://devfeed.tech/articles/sustaining-in-network-computation-in-satellite-networks-an-architecture-for-semantic-continuity-136983.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.19489>)

Author: Zhiyuan Ren, Wenchi Cheng

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>), [arXiv: Networking](<https://devfeed.tech/sources/arxiv-networking.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [resource orchestration](<https://devfeed.tech/topics/resource-orchestration.md>), [Network design](<https://devfeed.tech/topics/network-design.md>)

Tags: [acceptance](<https://devfeed.tech/tags/acceptance.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [computing](<https://devfeed.tech/tags/computing.md>), [context](<https://devfeed.tech/tags/context.md>), [continuation](<https://devfeed.tech/tags/continuation.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-ni](<https://devfeed.tech/tags/cs-ni.md>), [delivery](<https://devfeed.tech/tags/delivery.md>), [dependency](<https://devfeed.tech/tags/dependency.md>), [execution](<https://devfeed.tech/tags/execution.md>), [images](<https://devfeed.tech/tags/images.md>), [isolation](<https://devfeed.tech/tags/isolation.md>), [linux](<https://devfeed.tech/tags/linux.md>), [logical](<https://devfeed.tech/tags/logical.md>), [network](<https://devfeed.tech/tags/network.md>), [node](<https://devfeed.tech/tags/node.md>), [providers](<https://devfeed.tech/tags/providers.md>), [satellite](<https://devfeed.tech/tags/satellite.md>), [semantic](<https://devfeed.tech/tags/semantic.md>), [source](<https://devfeed.tech/tags/source.md>), [wildfire](<https://devfeed.tech/tags/wildfire.md>)

### AI overview

The paper proposes keeping one logical computation continuous as satellite paths and providers change. Its architecture separates logical computation, stream context, and physical binding: workers run ready operations, while consumers track which results already contribute. In wildfire assessment, retained observations support recomputation while reachable association history remains available. In a 300-node Linux prototype, stage-wise placement met deadlines for 82.08% of 120 image positions, compared with 76.06% for single-node placement. For 50 observations under 20-node isolation, Confirmation-Coordinated Rebinding coordinated replanning, source replay, cross-attempt acceptance, and in-band confirmation, completing all observations with verified outputs using seven replays and ignoring 13 duplicate outputs. The supplied text is an abstract/excerpt, so it does not establish broader performance or deployment results.

### Source excerpt

arXiv:2611.19489v1 Announce Type: cross Abstract: Satellite computations often outlast the paths and providers initially serving them. We argue that in-network computing should organize changing execution opportunities around one continuing logical computation: workers execute ready operations, while consumers recognize which results already contribute. We present an architecture separating logical computation, stream context, and physical binding, and show in wildfire assessment how retained observations support recomputation while reachable association history stays in place. A 300-node Linux prototype examines placement, dependency assembly, and continuation. Across 120 images, stage-wise placement delivers 82.08% of positions within deadlines versus 76.06% for single-node placement, while traces separate blocked output delivery from dependencies split across providers. Across 50 observations with 20-node isolation, Confirmation-Coordinated Rebinding (CCR) coordinates replanning, source replay, cross-attempt acceptance, and in-band confirmation to complete all 50 observations with verified outputs using seven replays and 13 ignored duplicate outputs.

## Federated Soft Poly-Level Learning Over a Distributed Network with Guaranteed Convergence

DevFeed: [Federated Soft Poly-Level Learning Over a Distributed Network with Guaranteed Convergence](<https://devfeed.tech/articles/federated-soft-poly-level-learning-over-a-distributed-network-with-guaranteed-convergence-135102.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.17722>)

Author: Yang Jiao, Kai Yang, Jianwei Huang

Published: 2026-11-16T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>)

Topics: [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [computational complexity](<https://devfeed.tech/topics/computational-complexity.md>)

Tags: [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [federated](<https://devfeed.tech/tags/federated.md>), [learning](<https://devfeed.tech/tags/learning.md>), [network](<https://devfeed.tech/tags/network.md>)

### AI overview

The proposed Federated Poly-Level Learning (FPLL) framework addresses soft-constrained optimization with four or more hierarchical levels when data is distributed across network nodes. It uses a nonlinear "L-cut" to relax the problem level by level, and adjustable algorithm parameters let users trade computational complexity against performance efficiency. The authors report a non-asymptotic iteration-complexity analysis for reaching an ε-Pareto stationary point and say experiments demonstrate the method's efficacy; the excerpt gives no quantitative results or specific experimental comparisons.

### Source excerpt

arXiv:2611.17722v1 Announce Type: new Abstract: Multi-level learning/optimization, e.g., bilevel optimization, has been recognized for its versatile applicability across a broad array of domains, spanning from signal processing to machine learning. However, most existing works focus on bilevel and trilevel optimization. In contrast, multi-level optimization problems involving four or more hierarchical levels, which we term poly-level learning (PLL) problems, remain largely unexplored.In addition, in practical PLL, data may be distributed across multiple nodes over a distributed network. Nevertheless, extant studies on PLL predominantly focus on the non-federated setting, necessitating the collection of data to central servers and thereby posing potential privacy risks. To this end, we propose a Federated Poly-Level Learning (FPLL) framework over a distributed network to tackle the PLL problems with soft constraints in a federated manner. FPLL hinges on a novel non-linear cut, i.e., $L$-cut, for the level-wise relaxation to the PLL problems. Additionally, the proposed federated algorithm is designed with adjustable parameters that allow for a flexible trade-off between its computational complexity and performance efficiency, enabling users to tune it according to specific application requirements. We also carry out non-asymptotic analysis to derive the iteration complexity for the proposed FPLL to achieve the $\epsilon$-Pareto stationary point. Extensive experiments have been undertaken to elucidate the superior efficacy of the proposed method.

## Smoothed Analysis for Distributed MIS

DevFeed: [Smoothed Analysis for Distributed MIS](<https://devfeed.tech/articles/smoothed-analysis-for-distributed-mis-131547.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.16302>)

Author: Dipan Dey, Fabien Dufoulon, William K. Moses Jr., Gopal Pandurangan

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [faster](<https://devfeed.tech/tags/faster.md>), [graph](<https://devfeed.tech/tags/graph.md>), [local-model](<https://devfeed.tech/tags/local-model.md>), [lower-bound](<https://devfeed.tech/tags/lower-bound.md>), [parameter](<https://devfeed.tech/tags/parameter.md>), [probability](<https://devfeed.tech/tags/probability.md>), [problems](<https://devfeed.tech/tags/problems.md>), [random](<https://devfeed.tech/tags/random.md>), [random-graph](<https://devfeed.tech/tags/random-graph.md>)

### AI overview

The paper finds that random edge toggling can speed up distributed MIS, but only above a threshold scale. Starting from any base graph, each possible edge is independently toggled with probability p. When p = β ln n/n for a sufficiently large constant β, a randomized LOCAL algorithm given only the perturbed graph computes its MIS in O(√log n) rounds with high probability. Conversely, for p ≤ (1/2−δ) ln n/n, for any fixed δ>0, some base graph still requires Ω(log n/log log n) rounds for every randomized LOCAL MIS algorithm. Thus the amount of smoothing needed for the stated speedup is optimal up to a constant factor.

### Source excerpt

arXiv:2611.16302v1 Announce Type: new Abstract: We study smoothed analysis of the distributed Maximal Independent Set (MIS) problem. Luby's algorithm computes an MIS in $O(\log n)$ rounds, while the recent $\Omega(\log n/\log\log n)$ lower bound of Khoury and Schild (2026) shows that it is nearly optimal even in the LOCAL model. We ask whether small random perturbations can overcome this worst-case barrier. Given an arbitrary base graph $G$ on $n$ nodes, we consider the smoothed graph $\mathcal{G}_s=G\triangle G(n,p)$, where $G(n,p)$ is an independent random graph and $\triangle$ denotes symmetric difference. Thus, each possible edge is independently toggled with probability $p$. We establish nearly tight bounds on the smoothing needed for faster distributed MIS. For every base graph $G$, when $p=\beta\ln n/n$ for a sufficiently large constant $\beta$, a randomized LOCAL algorithm, given only $\mathcal{G}_s$, computes an MIS of $\mathcal{G}_s$ in $O(\sqrt{\log n})$ rounds with high probability. This is almost quadratically faster than the worst-case lower bound. Conversely, if $p\le(1/2-\delta)\ln n/n$ for a fixed constant $\delta>0$, there exists a base graph on which every randomized LOCAL MIS algorithm requires $\Omega(\log n/\log\log n)$ rounds on the smoothed graph. Hence, the smoothing parameter required for this speedup is optimal up to a constant factor. These results show that smoothed analysis can overcome worst-case lower-bound barriers for distributed local graph problems.

## Network-Co-Designed Dynamic Sparsification for Dependable Distributed Robot Learning over 3GPP Networks

DevFeed: [Network-Co-Designed Dynamic Sparsification for Dependable Distributed Robot Learning over 3GPP Networks](<https://devfeed.tech/articles/network-co-designed-dynamic-sparsification-for-dependable-distributed-robot-learning-over-3gpp-networks-127840.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.13282>)

Author: G\\'eza Szab\\'o, Boldizs\\'ar Bunda

Published: 2026-11-11T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Networking](<https://devfeed.tech/sources/arxiv-networking.md>)

Topics: [AI Networking](<https://devfeed.tech/topics/ai-networking.md>), [distributed-training](<https://devfeed.tech/topics/distributed-training.md>), [Simulation](<https://devfeed.tech/topics/simulation.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [communication](<https://devfeed.tech/tags/communication.md>), [compression](<https://devfeed.tech/tags/compression.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-ni](<https://devfeed.tech/tags/cs-ni.md>), [delay](<https://devfeed.tech/tags/delay.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [federated](<https://devfeed.tech/tags/federated.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [framework](<https://devfeed.tech/tags/framework.md>), [implement](<https://devfeed.tech/tags/implement.md>), [latency](<https://devfeed.tech/tags/latency.md>), [learning](<https://devfeed.tech/tags/learning.md>), [links](<https://devfeed.tech/tags/links.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [network](<https://devfeed.tech/tags/network.md>), [networks](<https://devfeed.tech/tags/networks.md>), [robot](<https://devfeed.tech/tags/robot.md>)

### AI overview

The paper proposes dynamic sparsification that adjusts robot model-update compression to network byte budgets and time constraints, aiming to reduce communication under volatile uplink conditions. It describes two approaches: a standards-aligned SA6/5GC mapping using CAPIF with NEF, PCF and NWDAF plus AI-specific semantics; and a VASEAL-style role-reversed loop in which the learning system shares learning-state feedback and receives bounded, time-limited control intents. The mechanism was implemented in asynchronous federated reinforcement learning with heterogeneous simulated quadrupeds and emulated uplink impairments. The reported results suggest substantial communication reduction without material loss of learning progress in that studied setting; the abstract does not establish performance beyond it.

### Source excerpt

arXiv:2611.13282v1 Announce Type: new Abstract: Robot fleets performing distributed learning often face volatile uplink conditions like bandwidth variation, packet loss, and latency spikes that delay or destabilize training. We propose a network-co-designed dynamic sparsification loop that couples model-update compression to network-facing byte budgets and time constraints. We describe two realizations: (i) a standards-aligned SA6/5GC mapping that leverages CAPIF with NEF/PCF/NWDAF, enriched with AI-specific semantics; and (ii) a VASEAL-style role-reversed loop where the learning system exposes learning-state feedback and receives bounded, time-limited control intents. We implement the mechanism in an asynchronous federated reinforcement learning framework with heterogeneous simulated quadruped robots and reproducible uplink impairments via emulated network links. Results indicate that substantial communication reduction is achievable under dynamic constraints without materially degrading learning progress in the studied setting.

## Decentralized Ranking Aggregation via Gossip: Convergence and Robustness

DevFeed: [Decentralized Ranking Aggregation via Gossip: Convergence and Robustness](<https://devfeed.tech/articles/decentralized-ranking-aggregation-via-gossip-convergence-and-robustness-128089.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2602.22847>)

Author: Kerrian Le Caillec, Anna Van Elst, Igor Colin, Stephan Cl\\'emen\\c{c}on

Published: 2026-11-11T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>)

Tags: [aggregation](<https://devfeed.tech/tags/aggregation.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [decentralized](<https://devfeed.tech/tags/decentralized.md>), [ranking](<https://devfeed.tech/tags/ranking.md>), [robustness](<https://devfeed.tech/tags/robustness.md>), [stat-ml](<https://devfeed.tech/tags/stat-ml.md>)

### AI overview

The article studies how to reach consensus rankings when preference data is distributed across a network. Its approach uses random gossip: autonomous agents interact locally to compute a global ranking without a coordinator or central authority. The work focuses on convergence, resilience to corrupted nodes, and reducing communication costs. The supplied abstract describes the approach and its aims but gives no specific convergence results or robustness bounds.

### Source excerpt

arXiv:2602.22847v3 Announce Type: replace-cross Abstract: The concept of ranking aggregation plays a central role in preference analysis, and numerous algorithms for calculating median rankings, often originating in social choice theory, have been documented in the literature, offering theoretical guarantees in a centralized setting, \textit{i.e.}, when all the ranking data to be aggregated can be brought together in a single computing unit. For many technologies (\textit{e.g.} peer-to-peer networks, IoT, multi-agent systems), extending the ability to calculate consensus rankings with guarantees of convergence and resilience to potential contamination in a decentralized setting, when preference data is initially distributed across a communicating network, remains a major methodological challenge. Indeed, in recent years, the literature on decentralized computation has mainly focused on computing or optimizing statistics such as arithmetic means using gossip algorithms. The purpose of this article is precisely to study how to achieve reliable and resilient consensus on collective rankings in a decentralized setting, thereby raising new questions, robustness to corrupted nodes, and scalability through reduced communication costs in particular. The approach proposed and analyzed here relies on the robustness guarantees offered by random gossip communication, which allows autonomous agents to compute a global ranking consensus using local interactions only, without coordination or a central authority.

## On the Solvability of Sound Distributed Verification under Byzantine Faults

DevFeed: [On the Solvability of Sound Distributed Verification under Byzantine Faults](<https://devfeed.tech/articles/on-the-solvability-of-sound-distributed-verification-under-byzantine-faults-127789.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2606.13954>)

Author: Gilde Valeria Rodr\\'iguez, Borzoo Bonakdarpour, Armando Casta\\~neda, Sergio Rajsbaum

Published: 2026-11-11T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [blockchain](<https://devfeed.tech/tags/blockchain.md>), [certificate](<https://devfeed.tech/tags/certificate.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [crash](<https://devfeed.tech/tags/crash.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [election](<https://devfeed.tech/tags/election.md>), [linearizability](<https://devfeed.tech/tags/linearizability.md>), [overlap](<https://devfeed.tech/tags/overlap.md>), [safety](<https://devfeed.tech/tags/safety.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

The abstract gives tight solvability thresholds for reconstructing a target execution from partial observations in asynchronous message-passing systems with up to t failures: each execution element must initially be witnessed by at least t + 1 processes under crash failures, and 2t + 1 under Byzantine failures. For globally dependent safety properties such as consensus and linearizability, it says a certificate of t + 1 reports is needed to ensure at least one honest report. It concludes that sound distributed verification under Byzantine faults is achievable exactly when input overlap is at least 2t + 1.

### Source excerpt

arXiv:2606.13954v2 Announce Type: replace Abstract: Modern distributed systems, ranging from distributed tracing platforms to blockchain oracle networks, frequently rely on processes holding partial observations to collectively certify a global execution state. Under Byzantine failures, a single malicious process withholding or fabricating partial states renders sound verification impossible, as genuine observations remain indistinguishable from fabricated assertions. To overcome this impossibility, we study input overlap x: the minimum number of processes that initially witness each element of a target execution I. We formalize this challenge as the x-reconstruction problem in asynchronous message-passing systems with up to t failures, where the goal is for all correct processes to recover I completely given an input overlap x. We establish tight matching upper and lower bounds for solvability: under crash failures, x-reconstruction is solvable if and only if x >= t + 1; under Byzantine failures, x-reconstruction is solvable if and only if x >= 2t + 1. Finally, we connect these structural bounds to semantic verification. For globally dependent safety properties (such as consensus, linearizability, k-set agreement, and leader election), sound verification under Byzantine faults requires a certificate of size c = t + 1 to guarantee at least one honest report. Consequently, sound distributed verification under Byzantine faults is achievable if and only if the input overlap satisfies x >= 2t + 1.

## Self-stabilization and Byzantine Tolerance for Maximal Independent Set

DevFeed: [Self-stabilization and Byzantine Tolerance for Maximal Independent Set](<https://devfeed.tech/articles/self-stabilization-and-byzantine-tolerance-for-maximal-independent-set-127786.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2210.06116>)

Author: Johanne Cohen, Laurence Pilard, Fran\\c{c}ois Pirot, Jonas S\\'enizergues

Published: 2026-11-11T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>)

Tags: [adversarial](<https://devfeed.tech/tags/adversarial.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [independent](<https://devfeed.tech/tags/independent.md>), [network](<https://devfeed.tech/tags/network.md>), [stabilization](<https://devfeed.tech/tags/stabilization.md>)

### AI overview

The paper adapts Turau's self-stabilizing algorithm for constructing a maximal independent set to handle transient and arbitrary Byzantine faults. Byzantine nodes may keep nearby nodes out of the set indefinitely; the analysis bounds their impact by excluding nodes within distance 1 and some nodes at distance 2. Under a fair distributed daemon, the algorithm converges in O(Δn) rounds with high probability. A modified algorithm for anonymous systems under an adversarial distributed daemon converges in O(n²) moves, both in expectation and with high probability.

### Source excerpt

arXiv:2210.06116v4 Announce Type: replace Abstract: We analyze the impact of transient and Byzantine faults on the construction of a maximal independent set in a general network. We adapt the self-stabilizing algorithm presented by Turau for computing such a vertex set. Our algorithm is self-stabilizing and also works under the more difficult context of arbitrary Byzantine faults. Byzantine nodes can prevent nodes close to them from taking part in the independent set for an arbitrarily long time. We give boundaries to their impact by focusing on the set of all nodes excluding nodes at distance 1 or less from Byzantine nodes, and excluding some of the nodes at distance 2. As far as we know, we present the first algorithm tolerating both transient and Byzantine faults under the fair distributed daemon. We prove that this algorithm converges in $ \mathcal O(\Delta n)$ rounds w.h.p., where $n$ is the number of nodes and $\Delta$ is the maximum degree of the network. Additionally, we present a modified version of this algorithm for anonymous systems under the adversarial distributed daemon that converges in $\mathcal O(n^{2})$ moves both in expected value and with high probability.

## KKT-Perturbation-Aware Communication for Fully Distributed Online Convex Optimization with Nonseparable Coupling

DevFeed: [KKT-Perturbation-Aware Communication for Fully Distributed Online Convex Optimization with Nonseparable Coupling](<https://devfeed.tech/articles/kkt-perturbation-aware-communication-for-fully-distributed-online-convex-optimization-with-nonseparable-coupling-125454.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.11827>)

Author: Zhaoye Pan, Tao Li, Yunjie Guo, Guanpu Chen

Published: 2026-11-10T05:00:00Z

Content type: news

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>)

Tags: [communication](<https://devfeed.tech/tags/communication.md>), [convex](<https://devfeed.tech/tags/convex.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [online](<https://devfeed.tech/tags/online.md>), [optimization](<https://devfeed.tech/tags/optimization.md>)

### AI overview

The proposed randomized communication mechanism prioritizes agents' primal and dual information channels according to their estimated effect on the KKT operator. This addresses a limitation of triggering communication by state variation or consensus error: under nonseparable coupling, equal-sized errors can have different KKT effects. The method adapts coordinate descent's sampling principle to choose which channels to refresh, aiming to reduce the overhead of repeatedly exchanging full-dimensional beliefs. Under standard regularity assumptions, it achieves expected static regret and expected cumulative constraint violation of O(T^{2/3}). Numerical experiments report better learning and constraint enforcement per transmitted bit than belief consensus baselines.

### Source excerpt

arXiv:2611.11827v1 Announce Type: new Abstract: Nonseparable costs and coupled constraints in distributed online convex optimization often arise when system performance and operational constraints depend on the joint configuration of all agents and cannot be decomposed into individual contributions. Such nonseparability leads to fully distributed decision-making with challenging partial local information, where each agent evaluates its local primal-dual update using estimated global information via a local belief of the joint action and the shared Lagrange multiplier to be exchanged with neighbors. While the belief consensus established by prior works ensures no-regret learning, exchanging beliefs comprising full-dimensional primal and dual states at every round imposes a communication overhead that scales with both the joint decision dimension and the network size. Existing event-triggered schemes typically activate communication according to state variation or consensus error. Under nonseparable coupling, however, errors of equal magnitude can produce markedly different perturbations after passing through the KKT operator. We therefore propose a randomized KKT-perturbation-aware communication mechanism, where the triggering of each agent's primal and dual communication channels depends on their impact on the KKT operator. The proposed mechanism transfers the adaptive-sampling principle of coordinate descent from allocating computation across decision blocks to allocating communication across information channels: channels with larger estimated perturbations receive greater priority for refresh. Under standard regularity assumptions, the resulting algorithm achieves $O({T}^{2/3})$ expected static regret and $O({T}^{2/3})$ expected cumulative constraint violation. Numerical experiments demonstrate improved learning and constraint-enforcement performance per transmitted bit over belief consensus baselines.

## Distributed Intelligent Ad Hoc Routing Agents for Communication at Protests During Internet Shutdowns

DevFeed: [Distributed Intelligent Ad Hoc Routing Agents for Communication at Protests During Internet Shutdowns](<https://devfeed.tech/articles/distributed-intelligent-ad-hoc-routing-agents-for-communication-at-protests-during-internet-shutdowns-126789.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.10708>)

Author: Matthew Schmidheiser, Milena Radenkovic

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Networking](<https://devfeed.tech/sources/arxiv-networking.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [mesh networking](<https://devfeed.tech/topics/mesh-networking.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [agents](<https://devfeed.tech/tags/agents.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [communication](<https://devfeed.tech/tags/communication.md>), [cs-ni](<https://devfeed.tech/tags/cs-ni.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [internet](<https://devfeed.tech/tags/internet.md>), [routing](<https://devfeed.tech/tags/routing.md>)

### AI overview

The proposed intelligent ad hoc routing protocol uses distributed agents that adapt to social relationships and changing congestion to route messages during internet shutdowns. In the reported comparison, it achieves delivery rates comparable to or higher than the dynamic clique routing protocol it extends, while using notably fewer carriers; with larger device buffers, it also sends fewer message-related packets. The abstract describes these as overall results and does not provide numerical measurements or detailed operating conditions.

### Source excerpt

arXiv:2611.10708v1 Announce Type: new Abstract: Governments around the world are increasingly using internet shutdowns to block digital communication. Internet shutdowns are particularly dangerous during political protests, as they inhibit protesters' ability to organize and communicate critical, potentially life-saving information and may be used to prevent awareness of state-based violence. Recent prior works have explored secure, private messaging systems for use during political protests and internet shutdowns but have encountered long delivery delays or low delivery rates under challenging conditions. In this work, we explore the use of distributed, adaptive, social- and congestion-aware heuristics and efficient communication patterns to create an intelligent ad hoc routing protocol in which network agents learn and leverage the network social environment and monitor and respond to dynamic network congestion behaviour to route messages in a time- and resource-efficient manner. Through this exploration, we contribute an intelligent algorithm and protocol which overall achieves comparable or higher delivery rates relative to the leading dynamic clique routing protocol which it extends while also transmitting messages through notably fewer carriers and, when network devices have larger amounts of buffer storage, transmitting fewer message-related packets. We additionally contribute a further understanding of routing limitations and challenges and conceptualizations of extensions of intelligent dynamic clique routing to overcome them.

## Seamless Reconfiguration for DAG-BFT (Technical Report)

DevFeed: [Seamless Reconfiguration for DAG-BFT (Technical Report)](<https://devfeed.tech/articles/seamless-reconfiguration-for-dag-bft-technical-report-126695.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.00896>)

Author: Michael Yiqing Hu, Leander Jehl, Paul Franke-Bergmann, Jialin Li, Christian Berger

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [async](<https://devfeed.tech/topics/async.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [byzantine-fault-tolerance](<https://devfeed.tech/tags/byzantine-fault-tolerance.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [dag](<https://devfeed.tech/tags/dag.md>), [downtime](<https://devfeed.tech/tags/downtime.md>), [latency](<https://devfeed.tech/tags/latency.md>), [network](<https://devfeed.tech/tags/network.md>), [nodes](<https://devfeed.tech/tags/nodes.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [protocols](<https://devfeed.tech/tags/protocols.md>), [report](<https://devfeed.tech/tags/report.md>)

### AI overview

The report presents a protocol for reconfiguring membership in asynchronous DAG-based Byzantine atomic broadcast without halting DAG growth. Existing approaches described in the abstract either pause operation or wait for a predetermined epoch boundary; a single agreed switching round is difficult because dissemination may already have advanced before processes learn of it. The proposed protocol allows membership and corresponding quorum thresholds to change while the DAG continues growing. The authors claim it is the first seamless reconfiguration protocol for this setting in a fully asynchronous network.

### Source excerpt

arXiv:2610.00896v2 Announce Type: replace Abstract: Byzantine Atomic Broadcast in Asynchronous networks has been studied extensively for decades. In a fully asynchronous system with even one possible crash failure, the FLP impossibility result rules out deterministic consensus, motivating randomized protocols that achieve termination with probability one. More recently, DAG-Rider popularized a new abstraction in which processes continuously reliably broadcast blocks to construct a Directed Acyclic Graph (DAG) and then locally derive a total order using a randomized perfect coin. This separation of dissemination from ordering has renewed interest in asynchronous DAG-based Byzantine Fault Tolerance (BFT) and inspired numerous protocols that improve expected latency or throughput. Reconfiguration, however, remains largely unexplored. Existing DAG-based BFT protocols generally assume a static set of processes, whereas deployed systems must occasionally add or remove nodes in response to operational demands. Existing solutions are not seamless; they either pause the system or delay membership changes until a predetermined epoch boundary. This may be impractical and can introduce downtime. A single agreed switching round is difficult to use seamlessly: by the time processes learn it, the dissemination layer may already have advanced beyond it. In this work, we present a seamless reconfiguration protocol for Asynchronous DAG-based Byzantine Atomic Broadcast. Our protocol allows the DAG to continue growing while the membership and corresponding quorum thresholds change, without halting the system. To the best of our knowledge, ours is the first protocol to provide seamless reconfiguration for DAG-based Byzantine atomic broadcast in a fully asynchronous network.

## Adapting Multi-Stage Distributed Real-Time Systems Design to Vehicular Edge Computing

DevFeed: [Adapting Multi-Stage Distributed Real-Time Systems Design to Vehicular Edge Computing](<https://devfeed.tech/articles/adapting-multi-stage-distributed-real-time-systems-design-to-vehicular-edge-computing-126745.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.12370>)

Author: Niraj Kumar, Anant Gautam

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [real-time](<https://devfeed.tech/topics/real-time.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [resource orchestration](<https://devfeed.tech/topics/resource-orchestration.md>)

Tags: [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [edge-computing](<https://devfeed.tech/tags/edge-computing.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [stage](<https://devfeed.tech/tags/stage.md>)

### AI overview

The paper models remotely processed vehicular applications as multi-stage pipelines that access heterogeneous resources in sequence. It proposes a joint mapping and scheduling heuristic that extends optimal priority assignment to account for vehicle mobility and real-time constraints, aiming to build feasible schedules, minimize local-device energy use, and meet deadlines for offloaded jobs. In simulations, the approach consistently outperformed a baseline using the same delay-composition framework and a deadline decomposition-based approach. The supplied text reports simulation results but gives no numerical performance gains.

### Source excerpt

arXiv:2611.12370v1 Announce Type: new Abstract: Vehicular Edge Computing (VEC) aims to support computation-intensive applications in intelligent transportation systems while meeting stringent latency requirements. When processed remotely, applications require access to different resource types in a specific sequence, forming a multi-stage processing pipeline. This structure closely resembles multi-stage distributed applications executing across heterogeneous resources, making established multi-stage distributed real-time scheduling techniques well suited for modeling VEC systems. The resulting model accommodates diverse resource configurations and access patterns. Building on this model, we propose a joint mapping and scheduling approach that accounts for vehicle mobility and real-time constraints. The proposed heuristic extends optimal priority assignment for multi-stage systems to the VEC setting, to construct feasible schedules while minimizing local-device energy consumption and ensuring that offloaded jobs meet their deadlines. Extensive simulations show that the proposed approach consistently outperforms both a baseline based on the same delay-composition framework and a deadline decomposition-based approach.

## Multi-Node Transformers for Object Detection and Captioning Across Distributed Edge Networks

DevFeed: [Multi-Node Transformers for Object Detection and Captioning Across Distributed Edge Networks](<https://devfeed.tech/articles/multi-node-transformers-for-object-detection-and-captioning-across-distributed-edge-networks-125355.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.11291>)

Author: Saurabh Kumar, Dewant Katare, Prakriti Jain

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Transformers](<https://devfeed.tech/topics/transformers.md>), [Jetson Orin](<https://devfeed.tech/topics/jetson-orin.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [Jetson](<https://devfeed.tech/topics/jetson.md>)

Tags: [autoregressive](<https://devfeed.tech/tags/autoregressive.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-cv](<https://devfeed.tech/tags/cs-cv.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [detection](<https://devfeed.tech/tags/detection.md>), [device](<https://devfeed.tech/tags/device.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [edge](<https://devfeed.tech/tags/edge.md>), [execution](<https://devfeed.tech/tags/execution.md>), [int8](<https://devfeed.tech/tags/int8.md>), [jetson](<https://devfeed.tech/tags/jetson.md>), [jetson-orin](<https://devfeed.tech/tags/jetson-orin.md>), [jetson-orin-nano](<https://devfeed.tech/tags/jetson-orin-nano.md>), [latency](<https://devfeed.tech/tags/latency.md>), [memory](<https://devfeed.tech/tags/memory.md>), [networks](<https://devfeed.tech/tags/networks.md>), [nvidia](<https://devfeed.tech/tags/nvidia.md>), [object-detection](<https://devfeed.tech/tags/object-detection.md>), [pi-5](<https://devfeed.tech/tags/pi-5.md>), [raspberry-pi-5](<https://devfeed.tech/tags/raspberry-pi-5.md>), [transformers](<https://devfeed.tech/tags/transformers.md>)

### AI overview

The framework shares one visual encoder across object detection and dense region captioning, reusing image features for localization and description instead of encoding the image a second time. It allocates model stages and input streams across edge nodes based on execution time, memory, processor use, power limits, and tensor-transfer cost. On a six-device testbed, the unified INT8 model reached 38.1 FPS on a Jetson Orin Nano, using 3.5 GB peak memory and 11.8 W. With four concurrent streams, the proposed allocation achieved 35.2 FPS and 28.4 ms mean end-to-end latency, with 6.8 MB/s internode transfer.

### Source excerpt

arXiv:2611.11291v1 Announce Type: cross Abstract: This paper presents a unified transformer-based framework for object detection and dense region captioning across distributed edge networks. The architecture uses a shared visual encoder followed by detection, region extraction, and autoregressive language-decoding stages, allowing localization and region description to reuse the same image features. This design removes the second image-encoding path required by decoupled detection and captioning pipelines. To support execution on resource-limited devices, a workload-allocation formulation assigns model stages and input streams across connected edge nodes while accounting for execution time, memory capacity, processor utilization, power limits, and intermediate tensor transfer cost. The framework is evaluated on a six-device edge testbed comprising four NVIDIA Jetson Orin Nano and Orin NX inference nodes and two Raspberry Pi 5 auxiliary CPU nodes, with TensorRT FP16 and INT8 execution on the NVIDIA devices. On a Jetson Orin Nano, the unified INT8 model achieves 38.1 FPS with 3.5 GB peak memory use and 11.8 W measured power. Under four concurrent streams, the proposed allocation achieves 35.2 FPS and 28.4 ms mean end-to-end latency with an internode transfer rate of 6.8 MB/s.

## Distributed Consensus, Optimization, and Learning under Communication Constraints

DevFeed: [Distributed Consensus, Optimization, and Learning under Communication Constraints](<https://devfeed.tech/articles/distributed-consensus-optimization-and-learning-under-communication-constraints-119115.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.06524>)

Author: Zheng Chen, Nicol\\\`o Michelusi, Themistoklis Charalambous, Kaibin Huang

Published: 2026-11-05T05:00:00Z

Content type: tutorial

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [distributed-training](<https://devfeed.tech/topics/distributed-training.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [communications](<https://devfeed.tech/topics/communications.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [communication](<https://devfeed.tech/tags/communication.md>), [connectivity](<https://devfeed.tech/tags/connectivity.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [convergence](<https://devfeed.tech/tags/convergence.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-it](<https://devfeed.tech/tags/cs-it.md>), [delay](<https://devfeed.tech/tags/delay.md>), [design-principles](<https://devfeed.tech/tags/design-principles.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-coordination](<https://devfeed.tech/tags/distributed-coordination.md>), [eess-sp](<https://devfeed.tech/tags/eess-sp.md>), [exchange](<https://devfeed.tech/tags/exchange.md>), [flow](<https://devfeed.tech/tags/flow.md>), [fundamentals](<https://devfeed.tech/tags/fundamentals.md>), [intelligence](<https://devfeed.tech/tags/intelligence.md>), [learning](<https://devfeed.tech/tags/learning.md>), [learning-algorithms](<https://devfeed.tech/tags/learning-algorithms.md>), [math-it](<https://devfeed.tech/tags/math-it.md>), [network](<https://devfeed.tech/tags/network.md>), [network-connectivity](<https://devfeed.tech/tags/network-connectivity.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [performance](<https://devfeed.tech/tags/performance.md>), [principles](<https://devfeed.tech/tags/principles.md>)

### AI overview

The tutorial explains how consensus averaging and distributed optimization let networked nodes cooperate on shared objectives, and how communication conditions affect that cooperation. It highlights that information accuracy, exchange frequency, reliability, network connectivity, and uncertainty influence convergence, training delay, and model accuracy. Building on these fundamentals, it outlines design principles for communication-constrained distributed learning across network topologies and reviews communication-efficient approaches, particularly for wireless networks. The abstract identifies bridging theory and practice as an open need; it does not provide specific algorithm comparisons or implementation guidance.

### Source excerpt

arXiv:2611.06524v1 Announce Type: cross Abstract: Many modern engineering applications require distributed problem-solving in which multiple nodes in a network cooperate to achieve a common optimization objective. Numerous distributed optimization and learning algorithms rely on consensus-based distributed coordination to ensure network-wide agreement via iterative local interactions. In these algorithms, the accuracy, frequency, and reliability of information exchange among network nodes directly influence system performance, including convergence behavior, training delay, and model accuracy. This tutorial article adopts a bottom-up approach to present the fundamentals of consensus averaging and distributed optimization methods, and highlights the impact of network connectivity, information flow, and communication uncertainty on network cooperation and optimization performance. Building on these theoretical insights, we discuss key design principles for communication-constrained distributed learning across diverse network topologies and review common approaches to communication-efficient learning, particularly in wireless networks. Despite substantial progress, further efforts are needed to bridge the gap between theory and practice and fully realize the potential of cooperative and networked intelligence.

## Designing a reliable unplanned failover

DevFeed: [Designing a reliable unplanned failover](<https://devfeed.tech/articles/designing-a-reliable-unplanned-failover-121334.md>)

Original publisher: [Read original article](<https://planetscale.com/blog/designing-a-reliable-unplanned-failover>)

Author: Shlomi Noach

Published: 2026-11-05T00:00:00Z

Content type: article

Language: en

Sources: [PlanetScale](<https://devfeed.tech/sources/blog-planetscale.md>)

Topics: [read-replica](<https://devfeed.tech/topics/read-replica.md>), [Availability](<https://devfeed.tech/topics/availability.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [control-plane](<https://devfeed.tech/topics/control-plane.md>)

Tags: [admin](<https://devfeed.tech/tags/admin.md>), [detection](<https://devfeed.tech/tags/detection.md>), [durability](<https://devfeed.tech/tags/durability.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [failover](<https://devfeed.tech/tags/failover.md>), [freeze](<https://devfeed.tech/tags/freeze.md>), [neki](<https://devfeed.tech/tags/neki.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [primary](<https://devfeed.tech/tags/primary.md>), [wal](<https://devfeed.tech/tags/wal.md>)

### AI overview

Neki avoids promoting a replica based on Admin's failed health check alone. It compares replica reports of physical replication: a reachable replica still streaming from the primary blocks failover, while a reachable report of broken replication with no contradiction supports recovery; if Admin cannot reach any replica, it waits. Once it decides the primary is dead, Neki disconnects reachable replicas by changing `primary_conninfo`, preventing reconnection to a returning primary and freezing their WAL positions. Admin prefers a promotable replica that has replayed through the highest received WAL position, waits briefly for catch-up, then selects by `receive_lsn` and `replay_lsn`. The new primary is promoted and the others repointed; a replica ahead of it may need rewind or rebuild. With synchronous `ANY 1`, commits require an acknowledging replica, but acknowledged WAL can still be lost if the primary and the replica holding it fail together. Cross-availability-zone acknowledgements reduce that risk at the cost of commit latency. Async durability offers no guarantee that an unreachable primary has stopped accepting writes. Unrecoverable cases include having no reachable candidate.

### Source excerpt

How Neki detects a failed Postgres primary, and chooses a new one from the WAL that survived.

## Distributed LTL Synthesis under Arbitrary Message Adversaries

DevFeed: [Distributed LTL Synthesis under Arbitrary Message Adversaries](<https://devfeed.tech/articles/distributed-ltl-synthesis-under-arbitrary-message-adversaries-116491.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.04561>)

Author: Benedikt Bollig, Patricia Bouyer-Decitre, Matthias F\\"ugger, Dhrubajyoti Ghosh, Thomas Nowak, Nathalie Sznajder

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [consensus algorithm](<https://devfeed.tech/topics/consensus-algorithm.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Automaton](<https://devfeed.tech/topics/automaton.md>)

Tags: [adversary](<https://devfeed.tech/tags/adversary.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-fl](<https://devfeed.tech/tags/cs-fl.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-sy](<https://devfeed.tech/tags/cs-sy.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [eess-sy](<https://devfeed.tech/tags/eess-sy.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [graph](<https://devfeed.tech/tags/graph.md>), [linear](<https://devfeed.tech/tags/linear.md>), [logic](<https://devfeed.tech/tags/logic.md>), [message](<https://devfeed.tech/tags/message.md>), [processes](<https://devfeed.tech/tags/processes.md>), [reactive](<https://devfeed.tech/tags/reactive.md>), [regular](<https://devfeed.tech/tags/regular.md>), [synthesis](<https://devfeed.tech/tags/synthesis.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

For two processes communicating over unreliable links with at least one message delivered each round, LTL synthesis can still be undecidable--even when messages contain complete causal histories. For every ω-regular message adversary A, the abstract gives a decidability criterion: synthesis is decidable exactly when the image π(A), derived through iterated chromatic subdivision, is nowhere dense in [0,1]. In decidable cases, a procedure takes a deterministic parity automaton for A and a specification, decides realizability, and constructs an algorithm when one exists. The abstract also states that this decidability condition is equivalent to consensus being repeatedly solvable in bounded time.

### Source excerpt

arXiv:2611.04561v1 Announce Type: new Abstract: Reactive synthesis is the problem of generating a program that produces outputs satisfying a logical specification for every input stream. We study distributed synthesis for two processes communicating in rounds over unreliable links, with at least one message delivered in every round. Despite this delivery guarantee, we show that synthesis from linear temporal logic specifications is undecidable, even when messages carry the processes' complete causal histories. More generally, we give a complete characterization of the communication restrictions that make synthesis decidable. Restrictions are described by a message adversary $A$, a set of allowed infinite graph histories: sequences of communication graphs, each specifying which messages are delivered in a round. Iterated chromatic subdivision associates these histories with points in the unit interval, yielding an image $\pi(A) \subseteq [0,1]$. For every $\omega$-regular message adversary $A$, synthesis is decidable if and only if $\pi(A)$ is nowhere dense. In the decidable cases, our procedure takes a deterministic parity automaton for $A$ and a specification, decides realizability, and constructs a realizing distributed algorithm whenever one exists. Further, our topological arguments shed new light on the fundamental requirements of synthesis. They show that, for $\omega$-regular message adversaries, synthesis is decidable if and only if consensus is repeatedly solvable in bounded time. This links two previously unrelated problems from formal verification and distributed computing through the processes' uncertainty about communication.

## Quantum Advantage for Distributed Symmetry Breaking

DevFeed: [Quantum Advantage for Distributed Symmetry Breaking](<https://devfeed.tech/articles/quantum-advantage-for-distributed-symmetry-breaking-116471.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2609.26788>)

Author: Maxime Flin, Longcheng Li, Jukka Suomela

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [Quantum Computing](<https://devfeed.tech/topics/quantum-computing.md>), [quantum mechanics](<https://devfeed.tech/topics/quantum-mechanics.md>)

Tags: [3](<https://devfeed.tech/tags/3.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [all](<https://devfeed.tech/tags/all.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [can](<https://devfeed.tech/tags/can.md>), [colors](<https://devfeed.tech/tags/colors.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [examples](<https://devfeed.tech/tags/examples.md>), [first](<https://devfeed.tech/tags/first.md>), [graph](<https://devfeed.tech/tags/graph.md>), [graphs](<https://devfeed.tech/tags/graphs.md>), [independent](<https://devfeed.tech/tags/independent.md>), [labeling](<https://devfeed.tech/tags/labeling.md>), [quant-ph](<https://devfeed.tech/tags/quant-ph.md>), [quantum](<https://devfeed.tech/tags/quantum.md>), [quantum-advantage](<https://devfeed.tech/tags/quantum-advantage.md>), [symmetry](<https://devfeed.tech/tags/symmetry.md>)

### AI overview

The paper reports a distributed quantum algorithm that 3-colors cycles in O(1) rounds with high probability. As a consequence, it claims every locally checkable labeling problem solvable in O(log* n) rounds in the classical LOCAL model can be solved in O(1) rounds with high probability in the quantum-LOCAL model, including maximal independent set and maximal matching in bounded-degree graphs. The authors characterize these as the first natural graph-problem examples of an asymptotic quantum advantage in the LOCAL model; the supplied abstract gives no algorithmic details beyond these results.

### Source excerpt

arXiv:2609.26788v2 Announce Type: replace-cross Abstract: We present a distributed quantum algorithm that $3$-colors cycles in $O(1)$ rounds, with high probability. It follows that all locally checkable labeling problems (LCLs) that have round complexity $O(\log^* n)$ in the classical LOCAL model can be solved in $O(1)$ rounds in the quantum-LOCAL model, with high probability; this includes problems such as maximal independent set and maximal matching in bounded-degree graphs. This presents the first natural examples of graph problems with an asymptotic distributed quantum advantage for the LOCAL model; all prior examples that separate LOCAL and quantum-LOCAL are artificial problems constructed merely for the sake of demonstrating quantum advantage.

## Distributed Linear Bandits for Freshness-Aware Preprocessing in MEC-Enabled Digital Twin Networks

DevFeed: [Distributed Linear Bandits for Freshness-Aware Preprocessing in MEC-Enabled Digital Twin Networks](<https://devfeed.tech/articles/distributed-linear-bandits-for-freshness-aware-preprocessing-in-mec-enabled-digital-twin-networks-116505.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.05115>)

Author: Mariam Yahya, Setareh Maghsudi

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [DePIN](<https://devfeed.tech/topics/depin.md>), [smartdevices](<https://devfeed.tech/topics/smartdevices.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [aoi](<https://devfeed.tech/tags/aoi.md>), [arm](<https://devfeed.tech/tags/arm.md>), [bandits](<https://devfeed.tech/tags/bandits.md>), [collaboration](<https://devfeed.tech/tags/collaboration.md>), [computing](<https://devfeed.tech/tags/computing.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [data](<https://devfeed.tech/tags/data.md>), [delay](<https://devfeed.tech/tags/delay.md>), [devices](<https://devfeed.tech/tags/devices.md>), [digital-twin](<https://devfeed.tech/tags/digital-twin.md>), [digital-twins](<https://devfeed.tech/tags/digital-twins.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [linear](<https://devfeed.tech/tags/linear.md>), [networks](<https://devfeed.tech/tags/networks.md>), [processing](<https://devfeed.tech/tags/processing.md>), [servers](<https://devfeed.tech/tags/servers.md>)

### AI overview

The framework uses MEC servers to preprocess IoT data, reducing the volume sent to digital twins and their processing load. Digital twins first define CPU allocation strategies that meet task-class-specific age-of-information requirements under stated workload, delay, and update-generation bounds. MEC servers then use DistLinGapE, a distributed linear-bandit method, to collaboratively find the feasible strategy with the lowest expected freshness-normalized preprocessing delay. Numerical results report optimal feasible-strategy identification and reduced preprocessing delay under stationary task-class assignments and workload statistics; in evaluated settings, identification speedup was nearly proportional to the number of participating MEC servers.

### Source excerpt

arXiv:2611.05115v1 Announce Type: new Abstract: Digital twins (DTs) require timely updates from Internet of Things (IoT) devices to accurately represent the state of the corresponding physical systems, but transmitting large data volumes can compromise freshness. Moreover, different task classes have distinct computational demands and freshness requirements, while stochastic task generation and sizes complicate resource allocation. In this paper, we propose a freshness-aware framework in which multi-access edge computing (MEC) servers preprocess IoT data, reducing transmission volume and DT-server processing load. The framework establishes mutual support between DT and MEC servers. The DTs determine feasible CPU-allocation strategies guaranteeing class-specific age-of-information (AoI) requirements under specified workload, delay, and update-generation bounds. MEC servers collaboratively identify the feasible strategy minimizing expected freshness-normalized preprocessing delay. We formulate CPU-strategy selection as a fixed-confidence distributed best-arm identification problem in linear bandits, with MEC servers as agents and CPU allocations across task classes as arms. We employ DistLinGapE, a distributed collaborative learning method, to coordinate exploration and share observations. Numerical results show that the method identifies the optimal feasible strategy and reduces preprocessing delay when deployed under stationary task-class assignments and workload statistics. Collaboration yields an identification speedup nearly proportional to the number of participating MEC servers in the evaluated settings.

## Self-stabilising approximate clock synchronisation requires linear time

DevFeed: [Self-stabilising approximate clock synchronisation requires linear time](<https://devfeed.tech/articles/self-stabilising-approximate-clock-synchronisation-requires-linear-time-116496.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.04725>)

Author: Joel Rybicki

Published: 2026-11-04T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [Raft](<https://devfeed.tech/topics/raft.md>)

Tags: [2014](<https://devfeed.tech/tags/2014.md>), [2019](<https://devfeed.tech/tags/2019.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [all](<https://devfeed.tech/tags/all.md>), [argument](<https://devfeed.tech/tags/argument.md>), [arguments](<https://devfeed.tech/tags/arguments.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [based](<https://devfeed.tech/tags/based.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [can](<https://devfeed.tech/tags/can.md>), [clock](<https://devfeed.tech/tags/clock.md>), [clocks](<https://devfeed.tech/tags/clocks.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [computing](<https://devfeed.tech/tags/computing.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [consider](<https://devfeed.tech/tags/consider.md>), [crash](<https://devfeed.tech/tags/crash.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [linear](<https://devfeed.tech/tags/linear.md>), [requires](<https://devfeed.tech/tags/requires.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

Deterministic self-stabilising approximate clock synchronisation requires Ω(f) time to stabilise when up to f processes may be non-transiently faulty, even though approximate synchronisation without self-stabilisation can take time independent of f. This resolves an open question about whether these tasks are as hard as consensus or as easy as approximate agreement, and shows the cost of tolerating both transient and non-transient faults. The lower bound holds even when faulty processes only crash, clocks have no drift, and message delay is bounded and known. The proof uses a combinatorial topological argument to show that no fast finite-state protocol can keep clocks consistent across all executions.

### Source excerpt

arXiv:2611.04725v1 Announce Type: new Abstract: Synchronising the clocks of processes is a fundamental problem in distributed computing. We consider message-passing systems in which processes start in an arbitrary initial state (self-stabilisation) and up to $f$ processes may be non-transiently faulty. It is well known that synchronising clocks \emph{exactly} is at least as hard as consensus and requires $\Theta(f)$ time. In contrast, without self-stabilisation, clocks can be synchronised \emph{approximately} much faster, in time independent of the number of non-transient faults [Srikanth and Toueg, JACM 1987; Welch and Lynch, Inf. Comput. 1988]. In this work, we show that deterministic self-stabilising approximate clock synchronisation tasks require $\Omega(f)$ time to stabilise. This gives the first non-trivial time lower bound for these tasks, whose time complexity has remained open for over two decades [Dolev and Welch, JACM 2004; Dolev, F\"ugger, Schmid and Lenzen, JACM 2014]. In particular, this answers the open question whether self-stabilising approximate clock synchronisation tasks are as hard as consensus or as easy as approximate agreement [Lenzen and Rybicki, JACM 2019]. The results show that guaranteeing \emph{both} transient and non-transient fault-tolerance simultaneously is expensive even for approximate synchronisation tasks. The lower bounds hold in a very strong model: the faulty processes can only crash, the local clocks of processes have no clock drift, and the message delay is bounded and known to all processes. The proof is based on a combinatorial topological argument showing that no fast finite-state protocol can ensure that the clocks behave consistently across all executions. To our knowledge, this is the first use of topological arguments to prove time lower bounds in the self-stabilising setting.

## Computation in Anonymous Directed Dynamic Networks: Exact Worst-Case Termination Time and Network-Wise Intractability

DevFeed: [Computation in Anonymous Directed Dynamic Networks: Exact Worst-Case Termination Time and Network-Wise Intractability](<https://devfeed.tech/articles/computation-in-anonymous-directed-dynamic-networks-exact-worst-case-termination-time-and-network-wise-intractability-113800.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.01761>)

Author: Giuseppe A. Di Luna, Giovanni Viglietta

Published: 2026-11-03T05:00:00Z

Content type: news

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [computational complexity](<https://devfeed.tech/topics/computational-complexity.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [all](<https://devfeed.tech/tags/all.md>), [also](<https://devfeed.tech/tags/also.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [but](<https://devfeed.tech/tags/but.md>), [cases](<https://devfeed.tech/tags/cases.md>), [change](<https://devfeed.tech/tags/change.md>), [communication](<https://devfeed.tech/tags/communication.md>), [complete](<https://devfeed.tech/tags/complete.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [distributed-algorithm](<https://devfeed.tech/tags/distributed-algorithm.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [network](<https://devfeed.tech/tags/network.md>), [networks](<https://devfeed.tech/tags/networks.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

The paper gives a worst-case tight round bound for counting agents in anonymous, synchronously communicating directed networks whose graph may change arbitrarily but stays strongly connected. With ℓ known leaders, every agent can output the unknown population n and halt after n rounds when n=ℓ, 2n−1 rounds when n>ℓ and ℓ=1, or 2n−2 rounds when n>ℓ and ℓ>=2. The algorithm allows loops, parallel arcs, and agents that learn their outdegree only after sending. Its local computation is polynomial when each round's multigraph has at most 2^poly(n) arcs, requiring each agent to solve at most one linear system of up to n variables per round. Counting also supports evaluating any computable function of agents' input-value multiset within 2n−1 rounds. By contrast, deciding whether an agent already has enough information to determine n on a particular network is coNP-complete when parallel-arc counts are binary encoded.

### Source excerpt

arXiv:2611.01761v1 Announce Type: new Abstract: We determine the exact round complexity of Counting in anonymous directed dynamic networks. Agents have no identifiers, but $\ell\geq1$ of them are designated as leaders. Every agent knows $\ell$ and its own leader status, while the population size $n$ is unknown and has to be determined by the agents. Communication proceeds in synchronous rounds; the directed communication graph may change arbitrarily and unpredictably from one round to the next, but is assumed to remain strongly connected. We solve Counting with a distributed algorithm that makes every agent output $n$ and halt after a number of rounds equal to $\begin{cases} n&\text{if }n=\ell\\ 2n-1&\text{if }n>\ell\text{ and }\ell=1\\ 2n-2&\text{if }n>\ell\text{ and }\ell\geq2. \end{cases}$ The algorithm works even for networks with loops and parallel arcs and even when agents learn their outdegree only after sending. We prove that this bound is worst-case tight over directed multigraphs for every $n$ and $\ell$ with $1\leq\ell\leq n$. Moreover, the local computation is polynomial (provided that each communication multigraph has at most $2^{\operatorname{poly}(n)}$ arcs): in every round, each agent solves at most one linear system with up to $n$ variables. By standard techniques, solving Counting also enables the evaluation of any computable function of the multiset of agents' input values within $2n-1$ communication rounds. The bound above optimizes the worst case over all networks. For an individual network, we show that even deciding whether an agent already has enough local information to determine $n$ is $\mathsf{coNP}$-complete (provided that the numbers of parallel arcs are encoded in binary). Thus, worst-case-optimal Counting admits polynomial local computation, whereas exact network-wise optimization is intractable under standard complexity assumptions.

## QScale: Probabilistic Chained Consensus for Moderate-Scale Systems

DevFeed: [QScale: Probabilistic Chained Consensus for Moderate-Scale Systems](<https://devfeed.tech/articles/qscale-probabilistic-chained-consensus-for-moderate-scale-systems-113751.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2510.01536>)

Author: Hasan Heydari, Alysson Bessani, Kartik Nayak

Published: 2026-11-03T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [Blockchain](<https://devfeed.tech/topics/blockchain.md>)

Tags: [communication-complexity](<https://devfeed.tech/tags/communication-complexity.md>), [consensus](<https://devfeed.tech/tags/consensus.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [ledger](<https://devfeed.tech/tags/ledger.md>), [probabilistic](<https://devfeed.tech/tags/probabilistic.md>), [scale](<https://devfeed.tech/tags/scale.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

QScale targets distributed ledgers with a few hundred to a thousand processes, a scale the abstract says is poorly served by protocols designed for small systems or approaches requiring very large populations. It claims expected per-process communication of Õ(κ√n) and expected total communication of Õ(nκ) per block, with best-case finalization latency of O(κ) rounds. Safety and liveness are stated to hold with overwhelming probability; κ is a small security parameter.

### Source excerpt

arXiv:2510.01536v2 Announce Type: replace Abstract: Existing distributed ledger protocols either incur a high communication complexity and are thus suited to systems with a small number of processes (e.g., PBFT), or rely on committee-sampling-based approaches that only work for a very large number of processes (e.g., Algorand). Neither of these lines of work is well-suited for moderate-scale distributed ledgers ranging from a few hundred to a thousand processes, which are common in production (e.g, Redbelly, Sui). The goal of this work is to design a distributed ledger with sub-linear communication complexity per process, sub-quadratic total communication complexity, and low latency for finalizing a block into the ledger, such that it can be used for moderate-scale systems. We propose QScale, a protocol in which every process incurs only $\widetilde{O}(\kappa \sqrt{n})$ communication complexity per-block in expectation, $\widetilde{O}(n\kappa)$ total communication complexity per-block in expectation, and a best-case latency of $O(\kappa)$ rounds while ensuring safety and liveness with overwhelming probability, with $\kappa$ being a small security parameter.

## Salesforce acquires Rune Technologies to add offline capabilities to Missionforce

DevFeed: [Salesforce acquires Rune Technologies to add offline capabilities to Missionforce](<https://devfeed.tech/articles/salesforce-acquires-rune-technologies-to-add-offline-capabilities-to-missionforce-112550.md>)

Original publisher: [Read original article](<https://www.cio.com/article/4243245/salesforce-acquires-rune-technologies-to-add-offline-capabilities-to-missionforce.html>)

Author: Anirban Ghoshal

Published: 2026-11-02T12:58:03Z

Content type: news

Language: en

Sources: [CIO](<https://devfeed.tech/sources/cio.md>)

Topics: [Local-First](<https://devfeed.tech/topics/local-first.md>), [Data Infrastructure](<https://devfeed.tech/topics/data-infrastructure.md>), [distributed algorithm](<https://devfeed.tech/topics/distributed-algorithm.md>), [consistency](<https://devfeed.tech/topics/consistency.md>), [Access Control](<https://devfeed.tech/topics/access-control.md>)

Tags: [acquisition](<https://devfeed.tech/tags/acquisition.md>), [aerospace](<https://devfeed.tech/tags/aerospace.md>), [agentforce](<https://devfeed.tech/tags/agentforce.md>), [defense](<https://devfeed.tech/tags/defense.md>), [defense-tech](<https://devfeed.tech/tags/defense-tech.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [edition-us](<https://devfeed.tech/tags/edition-us.md>), [enterprise-applications](<https://devfeed.tech/tags/enterprise-applications.md>), [enterprise-applications-salesforce-vendors-and-providers](<https://devfeed.tech/tags/enterprise-applications-salesforce-vendors-and-providers.md>), [forecast](<https://devfeed.tech/tags/forecast.md>), [government](<https://devfeed.tech/tags/government.md>), [inventory](<https://devfeed.tech/tags/inventory.md>), [language-en](<https://devfeed.tech/tags/language-en.md>), [mesh-network](<https://devfeed.tech/tags/mesh-network.md>), [military](<https://devfeed.tech/tags/military.md>), [nfc](<https://devfeed.tech/tags/nfc.md>), [offline](<https://devfeed.tech/tags/offline.md>), [offline-first](<https://devfeed.tech/tags/offline-first.md>), [optimize](<https://devfeed.tech/tags/optimize.md>), [rune](<https://devfeed.tech/tags/rune.md>), [salesforce](<https://devfeed.tech/tags/salesforce.md>), [storytype-news](<https://devfeed.tech/tags/storytype-news.md>), [system-of-record](<https://devfeed.tech/tags/system-of-record.md>), [transportation](<https://devfeed.tech/tags/transportation.md>), [vehicles](<https://devfeed.tech/tags/vehicles.md>), [vendors-and-providers](<https://devfeed.tech/tags/vendors-and-providers.md>)

### AI overview

Salesforce is acquiring Rune Technologies to bring TyrOS's offline-first logistics capabilities into Missionforce. TyrOS caches last-known inventory, vehicle, and route information using NFC-based hardware so deployed units can forecast supplies, allocate resources, and make operational decisions without continuous connectivity. When connections return, it can exchange prioritized information across distributed nodes over a mesh network and synchronize data, restoring headquarters' visibility. Analysts cited improved continuity as a potential benefit, while warning that offline updates could create conflicting records on reconnection and that data security must be maintained across distributed locations. Salesforce says TyrOS is already deployed with the US Army and Marine Corps; the acquisition is intended to support a 10-year US Army modernization contract with a $5.6 billion ceiling. The deal is expected to close by April 2027.

### Source excerpt

Salesforce is in the process of acquiring US-based defense-tech startup Rune Technologies to add offline capabilities to Missionforce, its Agentforce avatar for national security, defense, aerospace, and government agencies. The startup's TyrOS platform will be used to extend Missionforce into frontline military logistics, enabling deployed units to forecast supply requirements, optimize resource allocation, and make operational decisions even when network connectivity is unavailable, the CRM software provider said in a statement. That is possible due to TyrOS's offline-first architecture that caches last-known information about inventory, vehicles, and transportation routes using NFC-based hardware, allowing deployed units to access operational data without a continuous connection to centralized systems, according to the company's website. The platform can also exchange prioritized information between distributed nodes through a mesh network when connectivity becomes available, the website showed. Currently, Missionforce acts as a system of record for personnel, equipment, and supplies across defense organizations, while providing tools for strategic planning. For CIOs of defense organizations, the acquisition could mean improved operational continuity and better utilization of available resources, said Premal Shah, principal analyst at Avasant. This would be helpful because frontline units could now continue to access critical logistics information and coordinate resource requirements during connectivity disruptions, rather than relying on manual records or waiting for centralized systems to become available, Shah added. Once connectivity is restored, information can be synchronized across distributed nodes, helping headquarters regain visibility into frontline requirements and make more informed decisions about resource allocation and resupply, he further added. However, implementing technologies such as TyrOS comes with its own set of risks, according to Pareekh

[Next page](<https://devfeed.tech/topics/distributed-algorithm.md?cursor=WyIyMDI2LTExLTAyVDEyOjU4OjAzKzAwOjAwIiwgImE3NGE3ZWM5LTI5NmItNGNhYi05YTMyLThhYTIxODU2MzEzMSJd>)