Some robot and human teams coordinate without radio. Instead they leave "digital pheromones": small records written onto cheap passive markers such as RFID tags fixed in the floor. A later agent that wants to find an object reads the tags it passes and follows the trail. These markers hold only a few hundred bits. When many objects and agents share the same tags, new records overwrite old ones, and trails break into disconnected pieces. Agents that lose the trail fall back to blind search. The usual remedy is to delete records after a fixed lifespan. That forces a bad choice. A short lifespan keeps trails to moving objects fresh but erases trails to objects that never move. A long lifespan preserves those trails but fills the tags faster.
We propose treating the tag field as a channel with a hard bit budget, in the spirit of task-oriented semantic communication: transmit only what the receiver needs for its task, here "which way to the object I'm looking for." Mobile agents have real compute; tags have none. So the agents would run a small learned encoder that decides what to write into each tag's few bits. Each write accounts for what nearby tags already encode and which objects are likely to be searched for. A learned decoder on the reading agent turns the codes from the last few tags into a direction. Our central bet is that fragmentation is mostly a problem of how capacity is allocated across objects and space, not of bits per record. A write policy that judges relevance should keep trails connected at several times less tag memory than tuned chronological evaporation. We also design the study so that a simple hand-written redundancy rule can falsify the need for learning.
Core Claim and How It Differs From Prior Work
The motivating evidence comes from the RFID pheromone line. Pervasive pheromone-based interaction with RFID tags stores a tuple per object (identifier, hop count, evaporation timestamp, diffusion bit) and shows that following gradients beats blind search. The same work reports that a high ratio of tracked objects to tag capacity produces broken trails, and that timestamp evaporation is its only defense. Making tuple spaces physical with RFID tags works within 512-bit ISO15693 tags by hand-mapping concepts to 1-byte name/value pairs from a pre-shared codebook. That is the closest existing idea to ours, but its codebook is static and it has no policy for what to keep when space runs out. Middleware such as TOTA attaches propagation and maintenance rules to tuples but assumes nodes have enough memory. It also names the lack of a method for choosing evaporation constants and payloads as an open problem. SLUG sidesteps saturation by storing only step counters on landed beacons.
The method comes from semantic communication. VQ-DeepSC maps features to indices in a shared learned codebook, a lookup table of vectors that sender and receiver both hold, and sends only the indices. Shao and Zhang use an information-bottleneck encoder, which keeps only the information relevant to the downstream task. A sparsity prior in that encoder switches off feature dimensions the task does not need. Semantic Communication With Memory lets the receiver's history help decoding. We reuse all three ideas. In every one of these systems, however, the channel is a point-to-point radio link and the receiver decodes immediately. In our setting the "channel" is a persistent, spatially spread medium. Many writers overwrite each other there, and readers arrive asynchronously, long after the write.
The three-way intersection appears unaddressed: the research file finds no work combining learned semantic encoding with stigmergic trails on capacity-limited markers. What we add is three things. First, a write policy that takes neighbouring tags into account and replaces evaporation. Second, a decoder that reads several tags at once, so a trail can survive the loss of an individual record. Third, a controlled test of whether learning is actually needed.
Research Program
The environment is a graph of cells, each holding one passive tag with capacity $B$ bits. A population of searcher agents receives queries "find object $q$," drawn from a query distribution $Q$. Objects come in mixed classes: static, slow-moving, and fast-moving. Agents move, see objects within a small radius, keep a bounded memory of their own sightings, and read or write only the tag under them. Writes fail with probability $p_f$, which models RFID interference and collision as described in Field-Based Coordination for Pervasive Computing Applications.
The encoder runs on an agent standing at a tag. It takes three inputs: the tag's current code, the agent's sighting memory, and the codes the agent read at its last $k$ tags. It outputs a new code of at most $B$ bits, made of a variable number of indices into a shared codebook. A sparsity prior, as in the information-bottleneck encoder above, sets how many indices are used. The decoder runs on a searcher. It takes the query $q$ and the codes from its last $k$ tags and outputs a distribution over next moves. The write policy $\pi$ is trained to solve
$$\min_{\pi}\; \mathbb{E}_{q\sim Q}\big[T_\pi(q)\big] \quad \text{subject to every tag code having at most } B \text{ bits},$$
where $T_\pi(q)$ is the number of steps a decoder-following searcher needs to reach object $q$ when tags are written by $\pi$. During training, the decoder learns to predict shortest-path directions as a supervised target. The write policy is trained on episode search cost using straight-through gradients through the quantized indices, followed by policy-gradient fine-tuning. Training happens offline in simulation. At deployment the codebook is frozen and shared, like the static codebook of the RFID tuple-space work but learned.
The analysis has two parts. First, we inspect what the learned policy actually writes: which objects get bits at which tags, and how this depends on object speed and query frequency. If a simple rule emerges from that inspection, we write the rule down and test it on its own as a baseline.
Baselines
The naive reference points are blind search and FIFO overwrite at equal capacity. Blind search is a random walk with local sensing, the fallback mode reported in the RFID pheromone work. FIFO overwrite keeps the Mamei tuple format and evicts the oldest entry when the tag is full. Both bound the problem from below.
The strongest existing method is timestamp evaporation over Mamei-style tuples from Pervasive pheromone-based interaction with RFID tags, with proactive and parasitic diffusion. To be fair, we grid-search the evaporation lifespan separately for each environment and capacity, using the same number of evaluation episodes we spend on the learned method's hyperparameter search. We also report an oracle variant that is given a per-object-class lifespan. That variant represents the best any chronological rule can do. We found no reported result on Lacuna for gradient-search time on the RFID testbed; the paper reports only that pheromone users were "significantly faster than blind search." We will therefore reproduce this baseline ourselves rather than quote a number.
Recency eviction is a further baseline. It applies the least-recently-used policy that gave the most consistent gains in CAL-MAPF to tag entries. The file reports no specific numbers for it either.
The most dangerous baseline is a hand-written redundancy-aware eviction rule. When a tag is full, it drops the entry whose next-hop direction is most predictable from the entries the writing agent just read at neighbouring tags. Ties are broken toward keeping objects that have been queried often.
Three ablations isolate the key ingredient. The first gives the learned write policy raw Mamei tuples instead of codebook indices, which separates relevance-aware allocation from compression. The second uses learned codebook indices with timestamp evaporation, which tests compression alone. The third uses a decoder that reads only the current tag ($k=1$), which tests whether multi-tag decoding is what bridges fragments.
The success criterion is that, across capacities from 64 to 4096 bits, the full method reaches a given median search time with at most half the tag capacity required by tuned evaporation. It must also beat the redundancy rule by a margin larger than seed-to-seed variation. The comparison holds compute, query streams, agent memory, write opportunities and $p_f$ fixed across all methods.
Why not just…?
Why not just use bigger tags? Saturation scales with the number of concurrently tracked objects and agents, not with a fixed load, as the RFID pheromone work argues. Larger payloads also need longer read and write dwell times, which fast-moving collectors do not have (Tsilomitrou et al.). This is still an empirical question, and we treat it as one. The capacity sweep traces search time against $B$ for every method. If tuned evaporation at 4× capacity matches our method at 1× for realistic object counts, then buying memory is the practical answer, and we would report that.
Why not just write a smarter eviction rule by hand? This is the real threat. Much of the benefit may come from a single insight: do not store what a neighbour already implies. That is why the redundancy-aware rule is a first-class baseline, and why any rule we extract from the learned policy is tested in isolation. If the hand rule closes most of the gap, the contribution becomes "relevance-based evaporation as a design rule for TOTA-style maintenance policies." That outcome is still useful, but it would mean the learned encoder is unnecessary.
Why not just entropy-code the existing tuples? Lossless coding shrinks each record a little but leaves the allocation problem untouched: it still keeps or drops whole objects by age. Shao and Zhang found that task-agnostic quantization wastes bits on content that does not matter for the task. The raw-tuple ablation, under learned and under chronological allocation, measures how much of any gain comes from allocation rather than encoding.
Why not just have agents radio each other, or have tags pool storage? Collaborative storage of the kind in Tilak et al. needs powered nodes that talk to each other, and passive tags cannot do that. Radio fails in exactly the walled, rubble-filled settings that motivate SLUG. Asynchronous traces also decouple agents in time, which radio cannot. We therefore scope the problem to radio-denied deployments rather than claim superiority over radio in general.
Proposed Experiments
The environments are the six SLUG grid topologies, including the 41×41 square and the complex rescue maps, plus maze, room and warehouse maps from the standardized MAPF suite described in Tracking Progress in MAPF. We use the 27×71 CAL-MAPF warehouse layout for skewed query distributions. For SLUG we report its result for context: it cut total swarm energy "by nearly an order of magnitude" against leader-follower search on the 41×41 grid. SLUG addresses a different task, coverage, so this is not a competing number. We vary object count from 10 to 200, the mix of static and moving objects, query skew, searcher population, and $p_f$ from 0 to 0.3.
The metrics are median and 90th-percentile steps to target, the fraction of queries that degrade to blind search, and trail connectivity. Trail connectivity is the fraction of (object, tag) pairs from which the decoder's greedy path reaches the object. We also report bits used per tag.
Three checks decide the outcome. The first is the mixed-speed regime. Our method's advantage over oracle per-class evaporation should be largest when static and fast objects share tags, because that is the dilemma chronological rules cannot resolve. If there is no advantage there, the claim fails. The second is generalization. A policy trained on room and maze maps must keep its advantage on held-out warehouse and street maps and at object counts twice those seen in training. Otherwise the gain is overfitting to the training environments. The third is the fragmentation-repair test. We delete a random 20–50% of tag contents mid-episode. The $k>1$ decoder should keep searches out of blind mode substantially more often than the single-tag decoder and evaporation baselines; if it does not, the multi-tag decoding component adds nothing.
A small physical replication on ISO15693 tags with handheld readers would come last. It would check only that the codes fit the 512-bit format and survive real write-failure rates.
References
- Pervasive pheromone-based interaction with RFID tags
- Making tuple spaces physical with RFID tags
- Programming stigmergic coordination with the TOTA middleware
- Stigmergy-based, Dual-Layer Coverage of Unknown Regions
- Vector Quantized Semantic Communication System
- Learning Task-Oriented Communication for Edge Inference: An Information Bottleneck Approach
- Semantic Communication With Memory
- Field-Based Coordination for Pervasive Computing Applications
- Caching-Augmented Lifelong Multi-Agent Path Finding
- Mobile Data-Mule Optimal Path Planning for Wireless Sensor Networks
- Collaborative storage management in sensor networks
- Tracking Progress in Multi-Agent Path Finding