How far does a hash-only sender go? A pre-registered map of sender memory versus bits for short text messages

Marcelo SamoilenkoarXiv 2026 · arXiv

TL;DR

This paper investigates an extreme form of asymmetric compression: a "dumb" sender that only computes hashes and a "smart" receiver that uses a large language model (LLM) to reconstruct the original text. While the scheme is incredibly memory-efficient for the sender, pre-registered experiments show it generally fails to outperform traditional in-domain compressors in terms of total bits and transmission airtime.

What Problem Does This Paper Address?

In many constrained communication environments—like LoRaWAN, satellite links, or APRS—every bit and every frame transmitted is expensive. To save bandwidth, we usually turn to compression. However, state-of-the-art neural compressors typically require the same heavy model to exist at both the sender and the receiver. This is a dealbreaker for tiny, low-power microcontrollers.

The author asks: Can we move all the "intelligence" to the receiver? Inspired by Slepian–Wolf coding, the paper explores a "hash-only" sender. The sender doesn't need a language model; it just sends a few bits of a hash for each chunk of text. The receiver then uses its own language model to "guess" which words match those hash bits.

Methods

The proposed protocol is a lossless, tag-verified scheme:

  1. Sender: Chops a short message (up to 255 bytes) into 2-byte chunks. For each chunk, it transmits only the top few bits of a keyed BLAKE2b hash (specifically, 10 bits for the first 8 bytes and 4 bits thereafter). It also sends an 8-bit length field and a 32-bit verification tag.
  2. Receiver: Uses a Qwen2.5-0.5B language model to perform a "hash-pruned beam search." It generates possible text sequences and immediately discards any that don't match the received hash bits.
  3. Verification & Fallback: If the receiver finds a candidate that matches the 32-bit tag, the message is delivered. If the search fails, the receiver sends a 2-byte Negative Acknowledgement (NACK), and the sender falls back to transmitting the raw text.

The author compared this against several baselines, including PPM (Prediction by Partial Matching) of various orders, and general-purpose short-text compressors like smaz2 and Unishox2.

Datasets

The study used the Taskmaster-1 dataset, which consists of English human-to-assistant dialogues.

  • Training: The baseline PPM models were trained on the official training split (~2.4 MB of text).
  • Evaluation: A pre-registered test run was conducted on 1,000 unique utterances (28 to 49 bytes long) randomly selected from the development split.

Key Insights and Ideas

  • Computational Asymmetry: The sender is "modest," requiring almost no RAM or CPU at runtime (only ~8 KB of code/data for the hashing). The receiver does the heavy lifting, using gigabytes of memory and GPU acceleration.
  • The "NACK Trap": The biggest hurdle isn't the compression ratio of successful messages; it's the cost of failure. On real-world links, the overhead of a NACK frame plus a fallback frame often erases the bit-savings gained from the successful "hash-only" transmissions.
  • Language Models as Priors: The experiment proves that an LLM can effectively act as a prior to resolve hash collisions, but the "search space" is still treacherous. Even with a powerful model, the true message can fall out of the beam search, leading to a costly failure.

Key Results

The results were a "negative, delimiting result"—the hash-only scheme did not "win" the primary competition.

  • Bit Cost: The hash-only sender cost 192.8 bits per message on average to ensure 100% delivery. This was 18.4 bits more than a simple in-domain PPM order-1 compressor.
  • Success Rate: The scheme delivered 85.7% of messages on the first attempt.
  • Memory Frontier: As shown in Figure 1, the hash-only scheme is only the "cheapest" option in a very narrow memory band (between 8 KB and 24 KB). Once the sender has enough memory to hold a basic PPM model (~25 KB), the traditional approach is superior.
Figure 1: Measured sender memory (host arm64 build, keyed BLAKE2b tag included in every sender) against mean bits per message to deliver 100%, on the 1,000 test utterances. The grey step is the lowest cost among the pre-registered senders that fit within a given memory; the scheme sets it from 8,190 B up to PPM order 1 at 24,844 B. The open diamond is the same sender with secondary analysis B, which changes receiver effort only. Values are in Table 1.
  • Airtime: On almost all tested links (LoRa, APRS, etc.), the hash-only scheme lost to PPM order-1 and even Unishox2 because the failures required extra frames.
Table 1: Sender memory against mean bits per message to deliver 100% (N = 1,000; 40 bits of overhead in every row; PPM in ideal bits). The scheme row includes the NACK and the raw fallback of failed first attempts. Last column: paired mean of the scheme’s cost minus the point’s, with 95% bootstrap interval; negative means the scheme spends fewer bits.

Limitations and Future Work

  • Scope: The study was limited to short English text. Results might differ significantly for other languages or longer messages.
  • Model Contamination: The author notes that they did not measure if the Taskmaster-1 data was present in the Qwen2.5 training set, which could artificially inflate the receiver's performance.
  • Hardware: Memory was measured on an arm64 host build, not a true microcontroller, though the author attempted to account for this.
  • Future Direction: The author suggests that for most practical uses, a small in-domain model at both ends remains the better design choice. Future work could involve more sophisticated pruning rules for PPM or exploring "lossy" variants of the hash-only scheme.

Summary updated

Abstract

Can a sender that only computes hashes, with a language model only at the receiver, transmit short human text more cheaply than a classical sender trained on the same domain? We answer with one pre-registered run on 1,000 English user utterances from Taskmaster-1. The primary endpoint is the cost per message to deliver 100% of the messages (hash bits, plus a 2-byte negative acknowledgement and the raw text when the first attempt fails), paired against an in-domain PPM order-1 sender. The hash-only sender delivered 857 of 1,000 messages on the first attempt and cost 192.8 bits per message, 18.4 bits more than PPM order 1 (95% bootstrap interval 10.9 to 26.3); by the pre-registered rule it spends more and is not equivalent within one byte. As secondary results we map measured sender memory against bits. The hash-only sender (8,190 B on a host build, keyed BLAKE2b tag included, as in every method) was the cheapest point in bits from 8,190 B up to, but excluding, PPM order 1 at 24,844 B, 45 to 46 bits below smaz2 and Unishox2; from PPM order 1 upwards, in-domain senders spend fewer bits, except order 2 pruned to 16 KiB. In airtime it loses to PPM order 1 on all five links priced, to Unishox2 on four, and to raw text with a tag on two, because each failure costs an acknowledgement frame and a fallback frame. A wider receiver search recovers half of the failures and makes the cost 7.7 bits lower than PPM order 1, at about three minutes of receiver time per failure, and still loses in airtime on four of five links. We report the measurement as a delimitation, with every deviation of the run.
BibTeX
@misc{samoilenko2026how,
  author = {Marcelo Samoilenko},
  title = {{How far does a hash-only sender go? A pre-registered map of sender memory versus bits for short text messages}},
  year = {2026},
  eprint = {2611.09848},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.09848},
}
Figure