Freshness or Throughput? Coordination Under Lossy Communication Depends on Staleness, Not Delivered Rate

We separate two quantities that real links degrade together — how stale peer information is (delay) and how much of it arrives (delivered rate) — and ask which one governs decentralized coordination. Sweeping both independently, coordination quality tracks staleness alone; delivered throughput is causally decoupled.

Chris Adams

Arboria Labs, Alpharetta, GA United States

Corresponding Author email: cadams@arborialabs.com

ORCID - Christopher Adams

Abstract

A real communication link degrades in two ways at once: messages arrive late (delay) and some arrive not at all (loss). Design intuition often treats these together as “bad connectivity,” but they are distinct resources — latency and throughput — and a system that is limited by one is not helped by fixing the other. We separate them. On a delivery-gated communication model in a simplified 3-D kinematic swarm simulator — where a peer link is exercised only if a packet actually survives an independent per-link Bernoulli drop — we sweep the drop probability $p \in [0, 0.99]$ against one-way delay $d \in \{0, 5, 10, 20\}$ steps for two decentralized primitives (gossip-consensus and flocking) on the mutual-rendezvous task. The result is a strong null for throughput: across the entire loss axis, from every link delivered to only $\approx 2\%$ of links surviving, coordination quality $Q$ moves by less than $0.012$ at fixed delay — while the same $Q$ falls by a factor of five along the delay axis. Even at $p = 0.99$ , zero-delay coordination is perfect ( $Q = 1.00$ ). Coordination on these peer-derived-target tasks is governed by information staleness, not delivered rate: the delivered-loss curves collapse onto a single delay curve. We validate the gating model against the ungated result (at $p = 0$ the two agree exactly) before trusting the sweep. The practical reading, relevant to any spatially distributed fabric that must coordinate over a shared medium — sensor fields, robot teams, and satellite constellations coordinating over lossy inter-node links — is that link capacity is the wrong thing to buy: coordination is bought with latency. We scope the claim precisely: this is a simulation-based algorithmic result about coordination primitives under lossy delay, not physical-device validation.

Keywords

Decentralized Coordination, Communication Delay, Packet Loss, Delivery Gating, Age of Information, Consensus, Rendezvous, Multi-Agent Systems, Satellite Constellations

1. Introduction

1.1. Background and Motivation. Decentralized coordination degrades when communication does. But “communication degrades” bundles two physically distinct failures. A link can be slow — peer state arrives, but describes where a neighbor was, not where it is. Or a link can be lossy — some messages never arrive, thinning the interaction graph. Latency and throughput are separately provisioned in real systems (a deep-space link has enormous delay but can be highly reliable; a congested mesh has low delay but drops heavily), and knowing which one bounds coordination tells a designer what to spend on. Our companion work [1] mapped coordination against delay with a fixed, reliable channel; here we add the orthogonal axis — delivered fraction — and ask whether it matters at all.

1.2. Problem Statement. We ask: holding the coordination primitive and task fixed, does decentralized coordination quality depend on the rate of delivered peer information, on its staleness, or on both? We make loss and delay two independent controlled axes on one substrate and measure a single normalized quality $Q$ across their product.

1.3. Contributions.

A delivery-gated evaluation in which a peer interaction occurs only if a message survives an independent per-link Bernoulli drop, so the interaction graph is thinned by exactly the delivered-loss process rather than by a topology proxy (§3.1).
A two-parameter sweep — packet-loss probability $\times$ delay — that separates staleness from delivered rate for two primitives on the rendezvous task (§3.2, §4).
A null result for throughput: coordination quality is flat across a $50\times$ reduction in delivered links at fixed delay, and the loss curves collapse onto a single staleness (delay) curve (§5).
A validation gate: at zero loss the gated graph reproduces the ungated result of [1] exactly, so the gating is neither adding nor subtracting links spuriously (§5.1).

1.4. Outline. §2 relates this to age-of-information and gossip-under-loss theory. §3 defines the gating model, metric, and primitives. §4 gives the setup. §5 presents the validation gate and the null. §6 discusses why, and the scope. §7 concludes.

2.1. Age of Information vs. throughput. The age-of-information literature [2, 3] established that freshness and rate are distinct and often opposed objectives — a channel maximizing throughput does not minimize the age of the most recent successfully delivered update. That work concerns a monitored source over a queue; we ask the downstream question for a closed-loop, many-body coordination task: given that freshness and rate differ, which one does the coordinated behavior actually track?

2.2. Consensus and gossip under packet loss. Average-consensus and randomized gossip converge under lossy or intermittent links provided the union of interaction graphs stays connected often enough [4, 5, 6]; loss slows convergence but does not, in general, prevent it as long as connectivity is preserved in expectation. Our measurement is consistent with — and quantifies the practical size of — this robustness: in a dense radius graph, even heavy loss leaves the swarm connected enough that convergence rate is barely touched, so the binding constraint is staleness.

2.3. Delay-coupled coordination. The delay axis and the harness are those of the companion phase-diagram study [1], where three primitives collapse together through a boundary near $10$ – $20$ steps. Here that delay axis is one of two; the second, delivered fraction, is new.

2.4. Positioning. We do not propose a new loss-tolerant algorithm. We provide the measured decoupling: on peer-derived-target tasks in this regime, delivered rate and coordination quality are causally independent, and only staleness binds — a statement about what to provision, not how to code.

3. Method

3.1. Delivery-gated communication. The engine’s communication model draws, for every in-range directed link each step, an independent Bernoulli survival with drop probability $p$ . Under delivery gating the coordination primitive only sees a peer edge that actually delivered — the interaction graph is the delivered graph, not the range graph. A pair of agents remains coupled this step if either direction’s packet survives, so the effective per-pair survival probability is $1 - p^2$ ; at $p = 0.99$ that is $\approx 0.02$ , i.e. only about one in fifty in-range pairs exchanges any information. The engine reports the delivered-edge list and running delivered/attempted counters, so the thinning is measured rather than assumed. Bandwidth is left unlimited, so the only thing loss changes is the delivered fraction — not a per-sender budget or a scan-order topology artifact.

3.2. Task, metric, and delay. We use the mutual-rendezvous task and the same normalized quality as [1],

Q_{\text{rendezvous}} = \exp\!\left(-\frac{\overline{\lVert \mathbf{x}_i - \bar{\mathbf{x}}\rVert}}{L_0}\right) \in [0,1],

a peer-derived-target objective — the centroid target is unknown to any isolated agent, so coordination is necessary and $Q$ is sensitive to missing or stale peer information. Delay is imposed exactly as in [1]: the primitive acts on the true swarm snapshot from $d$ steps ago while each agent’s own physics advances on true state, with actuation re-referenced to the agent’s true current velocity.

3.3. Primitives. Two primitives receive the gated, delayed peer view behind one act interface: gossip-consensus (one average-consensus round over the delivered neighbor graph) and flocking (fixed-weight Boids over the same graph). Gossip is the clean headline; flocking is included to check the null is not primitive-specific.

4. Experimental Setup

Runs use Gossamer (v0.6.0) primitives through Maneuver.Map’s vectorized policy seam, on the Leviathan engine (velocity-Verlet integrator) with delivery gating enabled (comm_collect_edges=1) and bandwidth unlimited. Energy and fault modules are disabled ( $\texttt{energy\_rate}=0$ , $\texttt{fault\_prob}=0$ ). The grid is primitive $\times$ loss $\times$ delay $\times$ seed $= 2 \times 8 \times 4 \times 5 = 320$ cells; loss $p \in \{0, 0.2, 0.4, 0.6, 0.8, 0.9, 0.95, 0.99\}$ , delay $d \in \{0, 5, 10, 20\}$ steps ( $\mathrm{dt}=1$ ), $N = 500$ , seeds 1–5. Every reported point is a mean over $5$ seeds.

5. Results

5.1. Validation gate. Before interpreting the loss sweep we confirm the gating model is faithful at its boundary: with $p = 0$ every in-range packet survives, so the delivered graph must equal the ungated range graph and the coordination numbers must match the companion study [1]. They do — gossip at $p = 0$ , delay $0$ gives $Q = 1.0000$ , and its delay cliff ( $1.00 \to 0.63 \to 0.43 \to 0.20$ across $d = 0, 5, 10, 20$ ) reproduces the dcc_p1 gossip-rendezvous curve to within seed spread. Gating neither adds nor subtracts links spuriously, so the sweep is trustworthy.

5.2. Throughput is decoupled from coordination. Fig. 1 (left) is the null. Holding delay fixed and sweeping loss from $p = 0$ (all links delivered) to $p = 0.99$ (effective pair-survival $\approx 0.02$ ), coordination quality is flat: for gossip, $Q$ ranges by at most $0.012$ across the entire loss axis at every delay (Table 1). A $50\times$ reduction in delivered links moves coordination quality by about one part in a hundred. At $p = 0.99$ and zero delay, gossip still reaches $Q = 1.00$ — near-total link loss costs nothing when information is fresh. Flocking shows the same flatness along the delivered axis, with only seed-level wobble at the two heaviest-loss, zero-delay cells (its polar-style compactness is noisier than gossip’s), and no systematic decline with loss.

$Figure 1. Left: coordination quality Q versus delivered-link fraction (1 − p²) at four fixed delays (gossip); the lines are flat — throughput does not move Q. Right: the same data as Q versus delay, one line per loss probability p (color); every loss curve collapses onto a single staleness curve. N = 500, 5 seeds.$

5.3. Staleness is what binds. Re-plotting the same grid as $Q$ versus delay, one curve per loss value (Fig. 1, right), the eight loss curves lie on top of one another and trace the single delay cliff of [1]. The two-parameter surface $Q(p, d)$ is, to measurement resolution, a function of $d$ alone: $Q(p, d) \approx Q^{\dagger}(d)$ . Staleness sets coordination quality; delivered rate does not enter.

Table 1. Coordination quality $Q$ for the gossip-consensus primitive versus one-way delay (integration steps) at each packet-loss probability $p$ (effective pair-survival $1 - p^2$ ), rendezvous task, $N = 500$ , mean over 5 seeds. From the committed dcc_p5 records. Each column is flat across $p$ .

$p$	$1-p^2$	$d=0$	$d=5$	$d=10$	$d=20$
0.00	1.00	1.000	0.634	0.432	0.201
0.20	0.96	1.000	0.634	0.432	0.201
0.40	0.84	1.000	0.634	0.432	0.201
0.60	0.64	1.000	0.634	0.432	0.201
0.80	0.36	1.000	0.634	0.433	0.202
0.90	0.19	1.000	0.635	0.433	0.202
0.95	0.10	1.000	0.636	0.434	0.203
0.99	0.02	1.000	0.643	0.444	0.213
range across $p$		0.000	0.009	0.012	0.012

An interactive version of the figure (hover for per-point values) is available as a companion artifact.

6. Discussion, Scope, and Limitations

Why throughput doesn’t bind here. On a peer-derived-target task the swarm needs the interaction graph to stay connected enough for information to diffuse toward a common target; it does not need every link. A dense radius graph ( $N = 500$ within comm_range) is highly redundant, so even at $2\%$ pair-survival the delivered graph retains a giant connected component each step and the mean-field target still propagates — only a hair slower, which the converging dynamics absorb. What loss cannot fix is age: every delivered packet, however many arrive, carries information that is exactly $d$ steps old, so staleness is common to all of them and binds regardless of rate. The decoupling should therefore be expected to fail in the sparse-graph limit, where loss can fracture connectivity — a boundary we did not cross here and flag below.

Scope. This is a simulation-based algorithmic result in a simplified 3-D kinematic engine, not physical-device validation. Three scope limits matter. (i) Density: the null holds in the connectivity-rich regime; near the percolation threshold, loss and staleness will re-couple, and locating that crossover is the natural follow-on. (ii) Independence: drops are i.i.d. per link per step; bursty or correlated loss (a link that stays down) can disconnect a region for many steps and is closer to a delay than to i.i.d. thinning. (iii) Task: the result is for peer-derived-target coordination; a task where an isolated agent can progress may weight delivered rate differently. Bandwidth is deliberately unlimited so that loss is the sole delivered-fraction knob; a bounded-bandwidth channel is a different (and, on this engine, topology-biased) axis and is out of scope.

Implication. For a distributed fabric that must coordinate over an unreliable shared medium, the design lever is latency, not capacity: within the connectivity-rich regime, provisioning more delivered throughput buys no coordination quality, while reducing staleness buys it directly. For satellite constellations coordinating over inter-node links this inverts a common instinct to over-provision link capacity — the same conclusion, from the delivered side, that motivates prioritizing fresh low-latency exchange over bulk delivery.

7. Conclusion

Separating how stale peer information is from how much of it arrives, decentralized coordination on peer-derived-target tasks tracks staleness alone: quality is flat across a $50\times$ cut in delivered links and collapses onto a single delay curve. Delivered throughput is causally decoupled from coordination quality in the connectivity-rich regime — a null that is arguably the more useful design result, because it says the scarce resource to manage is latency, not bandwidth. The natural next step is the sparse-graph boundary where loss fractures connectivity and the two axes must re-couple.

Data and Code Availability

All §5 numbers and Fig. 1 regenerate from the committed dcc_p5 experiment records (320 cells, 5 seeds each) via Maneuver.Map’s analysis path — aggregating task_metrics.Q_final over seeds by (algorithm, comm_loss_prob, delay). Delivery gating requires the Leviathan communication model that returns the delivered-edge list and cumulative delivered/attempted counters (comm_collect_edges=1); the validation gate of §5.1 compares against the companion dcc_p1 gossip-rendezvous cells. The pinned wheel and base-image identity, batch id, and seed tree are in Appendix B; the lab’s disclosure policy is at Reproducibility and Data Availability.

References

[1] Adams, C., “Phase Diagram of Decentralized Coordination Under Communication Delay,” Arboria Labs, 2026. /research/phase_diagram_coordination_communication_delay [2] Kaul, S., Yates, R., Gruteser, M., “Real-Time Status: How Often Should One Update?,” IEEE INFOCOM, 2012. [3] Yates, R. D., Sun, Y., Brown, D. R., Kaul, S. K., Modiano, E., Ulukus, S., “Age of Information: An Introduction and Survey,” IEEE J. Sel. Areas Commun., 2021. [4] Boyd, S., Ghosh, A., Prabhakar, B., Shah, D., “Randomized Gossip Algorithms,” IEEE Trans. Information Theory, 2006. [5] Kar, S., Moura, J. M. F., “Distributed Consensus Algorithms in Sensor Networks with Imperfect Communication: Link Failures and Channel Noise,” IEEE Trans. Signal Processing, 2009. [6] Patterson, S., Bamieh, B., El Abbadi, A., “Convergence Rates of Distributed Average Consensus with Stochastic Link Failures,” IEEE Trans. Automatic Control, 2010.

Appendix / Supplementary Material

Appendix A: Effective survival and the gating rule. Each directed in-range link delivers independently with probability $1 - p$ . A pair $(i, j)$ exchanges information this step if either $i \to j$ or $j \to i$ delivers, so the pair-survival probability is $1 - p^2$ . This is why the delivered fraction in Table 1 is written $1 - p^2$ rather than $1 - p$ : gating survives a pair if either direction gets through, and the sweep still reaches $\approx 2\%$ pair-survival at $p = 0.99$ . The null holds across this entire range.

Appendix B: Reproducibility checklist.

Canonical batch. Numbers and Fig. 1 derive from dcc_p5-20260710T233935-7fdfc793 (320 cells). The §5.1 validation gate compares against dcc_p1-20260707T225301-299e08d9 (the companion phase-diagram batch).

The grid. Primitive $\in \{$ gossip, flocking $\}$ $\times$ loss $p \in \{0, 0.2, 0.4, 0.6, 0.8, 0.9, 0.95, 0.99\}$ $\times$ delay $\in \{0, 5, 10, 20\}$ steps $\times$ seeds 1–5, on rendezvous at $N = 500$ .

Fixed parameters. dt=1.0, bound=1000, init_spread=500, comm_range=1200 (a connectivity-rich interaction graph), comm_collect_edges=1 (delivery gating on), bandwidth unlimited, energy_rate=0, fault_prob=0, integrator=velocity_verlet, steps=1500.

Environment. Gossamer 0.6.0 on the rebuilt leviathan-base carrying the delivered-edge communication model; Python 3.10.12 on Linux x86_64 (glibc 2.35), numpy 2.2.6, scipy 1.15.3, pandas 2.3.3, pyarrow 25.0.0; environment lockfile hash 4de1e199…. Each cell’s experiment.json records package versions, the lockfile hash, a hardware fingerprint, and the full seed tree; figures regenerate by aggregating task_metrics.Q_final over seeds by (algorithm, comm_loss_prob, delay).

Appendix C: Unified symbols. $Q$ (coordination quality), $d$ (delay in steps), $p$ (per-link drop probability) follow the shared conventions in the unified symbols table.

The delay companion is Phase Diagram of Decentralized Coordination Under Communication Delay.