The Network as a Rotating Broadcast Cache

Most distributed systems treat the network as a pipe. Data lives in nodes; the network is just the thing between them. You build protocols to decide what to send, when, and to whom. You add acknowledgements, retransmissions, routing tables, sync negotiation. Each layer solves a real problem, but each layer costs you — in bandwidth, latency, complexity, and power.

What if the data just lived in the network itself?

The setup

Consider a small mesh network — say, 5 to 20 nodes — using a TDMA radio protocol. Each node gets periodic time slots to transmit. The total application state across all nodes is small: under 100KB, not including images or bulk media. Think team positions, sensor readings, short messages, tactical state.

Three properties of this scenario matter:

TDMA slots have a minimum cost. Whether you fill a slot with useful data or a tiny keep-alive packet, you're spending roughly the same airtime. An administration packet alone in a slot is brutally expensive — you've burned your transmission opportunity on overhead.

The dataset is small relative to radio capacity. If each node can transmit a few hundred bytes per slot, and the full dataset is tens of kilobytes, the entire system state can cycle through the network in seconds.

Radio is inherently multicast. Every transmission is heard by every node in range. You don't choose recipients — physics does the fanout for free.

The collapse

In a conventional system, you'd build this as layers: a radio layer providing reliable links, a routing layer for multi-hop delivery, a sync protocol to track who has what, and an application on top. Each layer is general-purpose. Each adds coordination overhead.

But look at what we actually need: a handful of nodes, continuously converging on a small shared dataset, over a broadcast medium with fixed-size transmission slots.

So collapse it. No sync protocol. No ACKs. No NAKs. No routing table. No control plane at all.

Each node simply broadcasts its current state — or a deterministic slice of it — in every slot it gets. Every node that hears a packet merges the contents into its local state. The data rotates through the network continuously, like a cache that lives in the air.

A node that misses a packet doesn't request retransmission. It just waits. The data comes around again next cycle. A node that joins late doesn't need a catch-up protocol. It simply listens until it's heard a full rotation. Convergence isn't negotiated — it's a function of time and the broadcast schedule.

Why this works: CRDTs as the missing piece

This only works if the data model tolerates uncoordinated, unordered, potentially duplicated delivery. Which is exactly what Conflict-free Replicated Data Types (CRDTs) were designed for.

A CRDT's merge operation is idempotent, commutative, and associative. You can apply the same update twice — no harm. You can receive updates out of order — same result. You don't need to know who sent a message at the radio layer, because the data itself carries its own identity and causal metadata. The "who" lives in the data, not in the protocol.

This means the radio layer needs no concept of identity, sessions, or reliability. It just moves bytes. The data model handles the rest. The properties of CRDTs and the properties of broadcast RF are perfectly complementary — each eliminates the problems the other would normally create.

Bounded convergence, for free

The convergence time of this system is straightforward:

time to converge ≈ total dataset size / aggregate broadcast bandwidth

If 10 nodes each transmit 256 bytes per slot at 10 slots per second, that's roughly 25KB/s of aggregate data throughput cycling through the mesh. A 50KB dataset converges in about 2 seconds. Not eventually — predictably.

This is a stronger guarantee than most distributed systems offer, and it comes from the radio schedule alone. No protocol negotiation required.

Prior art and context

This idea sits at the intersection of several well-explored areas:

• Epidemic (gossip) protocols [Demers et al., 1987] spread updates probabilistically through random pairwise exchange. Our approach replaces probabilistic gossip with deterministic broadcast — every transmission reaches all neighbors simultaneously.
• NORM (NACK-Oriented Reliable Multicast, RFC 5740) inverts the usual approach by having receivers report missing data rather than confirming received data. We go further: no feedback at all. The continuous broadcast cycle makes explicit loss detection unnecessary.
• Trickle (RFC 6206) is a polite gossip algorithm for constrained networks that reduces redundant transmissions when nodes are already in sync. The philosophy is similar — minimise coordination — but Trickle still requires consistency checks between nodes. We eliminate even those.
• CRDTs [Shapiro et al., 2011] provide the data-model foundation that makes all of this safe. Without mergeable, order-independent state, you'd need the coordination overhead we're trying to remove.

The novel contribution is not any one of these ideas, but the recognition that for a specific constrained regime — small dataset, few nodes, broadcast medium, fixed-size slots — they can be collapsed into a single mechanism with no control plane at all.

Constraints and applicability

This is emphatically not a general-purpose architecture. It works when:

• The total shared dataset is small (order of tens of kilobytes)
• The node count is small (tens, not hundreds)
• The radio medium is broadcast (shared spectrum, not point-to-point)
• The application tolerates convergence on the timescale of a broadcast cycle
• The data model supports conflict-free merging (CRDTs or equivalent)

Scale any of these dimensions up significantly and the economics change. Larger datasets don't cycle fast enough. More nodes create contention. Point-to-point links lose the free multicast property.

But within these constraints — which describe a surprisingly large number of real-world team coordination and tactical networking scenarios — it's a remarkably simple and robust architecture. Zero coordination overhead. Predictable convergence. And a data replication protocol that consists, in its entirety, of "keep transmitting."

The authors have backgrounds in CRDT-based distributed databases and sub-GHz mesh radio protocol design. This work is motivated by practical challenges in small-team tactical communication where conventional layered network architectures impose disproportionate overhead.