Encode-Once, Decode-Many (EODM) Principle

• Encode-Once, Decode-Many (EODM) is an architectural principle that decouples a one-time costly encoding process from multiple downstream decodings, enhancing efficiency.
• It underpins diverse applications such as cognitive embeddings in the Tensor Brain, offline news representation in recommender systems, genomics compression, collective communications, relay networks, and DRAM error correction.
• By reusing encoded objects, EODM streamlines computations, reduces energy consumption, and minimizes redundant processing, leading to measurable performance and sustainability benefits.

Encode-Once, Decode-Many (EODM) denotes an architectural principle in which a computationally or semantically expensive encoding step is performed once to create a reusable representation, codeword, compressed artifact, or communication state, and that single encoded object is then decoded repeatedly by multiple downstream mechanisms. In recent arXiv literature, the same label is used for a two-layer representation/index architecture in the Tensor Brain, a decoupled content-based news recommender, a compressed-resident genomics pipeline with GPU random access, a universal collective communication primitive in synchronous systems, a multi-block relay coding scheme, and a cross-layer ECC stack for DRAM/HBM protection (Tresp et al., 2024, Liu et al., 2023, Shavidze, 17 Jun 2026, Wang et al., 2022, Lim et al., 2015, Kim et al., 4 May 2026).

1. Conceptual scope and recurring structure

Across these formulations, the encoded object is not fixed. It may be a cognitive brain state and concept embedding, a cached item embedding table, a self-contained compressed archive plus coordinate index, a universal communication schedule with matrix-specific coefficients, a source-selected network code over multiple blocks, or a single ECC codeword whose redundancy is reused by several decoders. What remains invariant is the asymmetry between a one-time encoding stage and a plural decode stage.

Domain	Encode-once object	Decode-many outcome
Tensor Brain	CBS $(q,\gamma)$ and embeddings $a_k$	concepts, predicates, episodic indices, embodiment
News recommendation	frozen news vectors $n_i=f_{\mathrm{enc}}(x_i)$	user modeling, matching/ranking, loss optimization
Genomics	ACEAPEX compressed archive and compact index	whole-file, range, and per-read GPU decodes
Synchronous systems	universal all-to-all schedule	distinct outputs $\hat{x}_k$ at all processors
Relay networks	source multicoding over multiple blocks	relay partial decodes and destination recovery
Cross-layer ECC	single 288-bit codeword	L-ECC detection, O-ECC repair, S-ECC recovery

A common misconception is to equate EODM with simple feature caching. The cited literature uses the term more broadly. In some settings, “decode” means symbolic inference or perceptual reconstruction; in others it means region extraction, collective linear evaluation, partial-message forwarding, or layered error recovery. This suggests that EODM is best understood as a reuse principle rather than a domain-specific algorithm.

2. Representation-centric EODM: from concept embeddings to cached recommendation vectors

In the Tensor Brain, EODM is implemented by a two-layer architecture consisting of a representation layer and an index layer (Tresp et al., 2024). The representation layer contains $n$ ensembles, with pre-activations $q=(q_1,\dots,q_n)\in\mathbb{R}^n$ and post-activations $\gamma=(\gamma_1,\dots,\gamma_n)$ given by

$$\gamma_i \leftarrow \operatorname{sig}(q_i) = (1+\exp(-q_i))^{-1}.$$

Its dynamics are

$$q_i(\tau) \leftarrow q_i(\tau-1) + g_i(v(\tau)) + f_i^{NN}(\gamma(\tau-1)),$$

where $g$ maps sensory input to the representation layer and $a_k$0 models recurrence and self-memory via skip connections. The index layer provides symbolic indices for concepts, predicates, and episodic instances, each with sparse embedding vector $a_k$1 and bias $a_k$2. Bottom-up decoding from a cognitive brain state uses

$a_k$3

while top-down symbolic write-back uses

$a_k$4

or, for multiple labels, $a_k$5. Attention provides a parallel decoder,

$a_k$6

The paper characterizes the embedding $a_k$7 as the concept’s “DNA”: a single vector consolidated from multisensory, episodic, and semantic contexts. That single vector supports symbolic decodes across domains, episodic decodes via time indices, and embodied decodes through an approximate inverse perceptual mapping $a_k$8.

The OLEO recommender instantiates EODM in a more conventional ML systems form (Liu et al., 2023). News representation learning is explicitly decoupled from downstream recommendation. A task-agnostic encoder $a_k$9—either a self-supervised Multi-Field Transformer or a PLM such as BERT—computes

$n_i=f_{\mathrm{enc}}(x_i)$0

once offline; the vectors are cached in a fixed embedding table; and downstream models $n_i=f_{\mathrm{enc}}(x_i)$1 operate only on cached news embeddings and user behavior. The Stage 1/Stage 2 split is explicit: precompute all $n_i=f_{\mathrm{enc}}(x_i)$2, freeze $n_i=f_{\mathrm{enc}}(x_i)$3, then train only the user model and scoring module. For subsequent epochs, $n_i=f_{\mathrm{enc}}(x_i)$4 and $n_i=f_{\mathrm{enc}}(x_i)$5. In MIND-large, the paper reports that a news article can appear around 1818 times within a training epoch, which makes repeated PLM forward passes especially redundant. Under this decoupled design, measured carbon emissions drop sharply while accuracy remains competitive: for example, on MIND-large with BST, PLMNR-BST has $n_i=f_{\mathrm{enc}}(x_i)$6 whereas OLEO MFT-BST has $n_i=f_{\mathrm{enc}}(x_i)$7, an $n_i=f_{\mathrm{enc}}(x_i)$8 reduction; the paper summarizes the overall reduction as “up to 13× lower carbon emissions.”

The two cases illustrate different extremes of the same principle. In the Tensor Brain, the encoded object is a subsymbolic global workspace state and its learned concept embeddings; in OLEO, it is a frozen table of content embeddings. In both, decode-many means that heterogeneous downstream operators reuse the same encoded content rather than re-encoding raw inputs.

3. Compressed-resident EODM in genomics

In compressed-resident genomics, EODM is formulated as a storage-and-query strategy rather than a learning architecture (Shavidze, 17 Jun 2026). A FASTQ stream is encoded once into ACEAPEX’s “absolute-offset parallel LZ77” together with a compact coordinate index. The encoded output is partitioned into fixed-size 16 KB blocks that are self-contained and independently decodable. Each block stores literals, match lengths, absolute source offsets, and the command sequence. The decoding rules are

$n_i=f_{\mathrm{enc}}(x_i)$9

where a match token carries the absolute source index $\hat{x}_k$0 and length $\hat{x}_k$1. Unlike DEFLATE’s positional $\hat{x}_k$2 references, ACEAPEX stores $\hat{x}_k$3 explicitly, eliminating sliding-window dependence and enabling parallel match resolution and position-invariant seeks.

This structure supports three decode modes from the same encoded artifact: whole-file decode, range decode, and per-read random access. Position-invariant random access is defined so that decode time depends primarily on a fixed launch cost rather than the absolute query position within the file. The reported latency on a 5 GB genome is 0.365 ms for a 1-block seek and 0.394 ms for a 100-block seek, while read-level random access is 0.362 ms per read end-to-end. The read-to-block index uses 8 bytes/read; for approximately 5 million reads in a 1.34 GB cleaned FASTQ, the index is approximately 40 MB versus a .fai of approximately 250 MB, i.e. 6.3× smaller. The paper reports that ACEAPEX is approximately 6× faster than warm samtools faidx, with both paths bit-perfect.

EODM here is strengthened by full device residency. Both entropy decode and match resolution execute on GPU, with outputs kept in VRAM. The paper reports up to 260.0 GB/s on FASTQ NA12878 (1 GB, ratio 11.19), 168.9 GB/s on ERR194147 5 GB, and 165.7 GB/s sustained in range-decode mode on a 50 GB genome where whole-file device decode would run out of memory. Because the compressed genome can remain resident in VRAM—12.7 GB for a 50 GB input in the reported example—only requested regions need be decoded and passed directly to downstream GPU consumers, avoiding the approximately 39 GB/s PCIe D2H ceiling. In this setting, “decode many” means repeated low-latency region materialization from a single offline compression pass.

4. Communication-theoretic and network-theoretic formulations

In synchronous decentralized computation, EODM appears as the “all-to-all encode” primitive (Wang et al., 2022). Each processor initially holds one scalar packet $\hat{x}_k$4, and all processors require distinct linear combinations specified by a generator matrix $\hat{x}_k$5:

$\hat{x}_k$6

The paper’s EODM interpretation is explicit: the system uses one coordinated universal communication schedule that does not depend on $\hat{x}_k$7; only the linear coefficients inside transmissions depend on $\hat{x}_k$8; and the same encoded traffic lets all nodes decode their distinct outputs simultaneously. The universal “prepare-and-shoot” algorithm computes any matrix in the synchronous complete-network, $\hat{x}_k$9-port, linear network model. It achieves the optimal round complexity

$n$0

matching the lower bound $n$1, and attains an exact $n$2 given by the paper’s parity-dependent formulas in terms of the largest integer $n$3 with $n$4. For DFT matrices with $n$5, the paper gives a stricter optimum:

$n$6

Thus, EODM in this setting is a communication primitive: one schedule, many decodes, all outputs in one pass.

Distributed decode-forward in relay networks provides a distinct network-theoretic formulation (Lim et al., 2015). The source “precod[es] all the codewords of the entire network at the source by multicoding over multiple blocks,” thereby embedding partial message information implicitly into auxiliary indices and codewords. Relays decode only the auxiliary information relevant to them and forward it further; destinations perform their own decoding from the accumulated structure. In the unicast construction, the source selects indices so that

$n$7

and relay $n$8 decodes $n$9 from $q=(q_1,\dots,q_n)\in\mathbb{R}^n$0. Here, the encode-once step is not a cached vector or static artifact; it is a single, globally coordinated multicoding operation across blocks. The decode-many stage is distributed across relay nodes and destinations. For Gaussian unicast, multicast, and broadcast relay networks, the scheme achieves within $q=(q_1,\dots,q_n)\in\mathbb{R}^n$1 bits from the cutset bound and thus from the capacity region, regardless of network topology, channel gains, or power constraints.

The two formulations occupy different technical regimes—one deterministic and synchronous, the other probabilistic and information-theoretic—but both treat EODM as a mechanism for simultaneous many-target recovery from one coordinated encoding strategy.

5. Cross-layer ECC as EODM: one codeword, three protection roles

Cerberus gives EODM a hardware reliability interpretation (Kim et al., 4 May 2026). The memory controller performs a single encoding per 32-byte (256-bit) block and emits one codeword whose redundancy is reused by link ECC, on-die ECC, and system ECC. The formal code parameters are

$q=(q_1,\dots,q_n)\in\mathbb{R}^n$2

with

$q=(q_1,\dots,q_n)\in\mathbb{R}^n$3

where $q=(q_1,\dots,q_n)\in\mathbb{R}^n$4 are two 16-bit redundancy portions. The controller computes the codeword once; the same redundancy is then viewed through different parity-check matrices:

• device/link layer: $q=(q_1,\dots,q_n)\in\mathbb{R}^n$5 with syndrome $q=(q_1,\dots,q_n)\in\mathbb{R}^n$6;
• system layer: $q=(q_1,\dots,q_n)\in\mathbb{R}^n$7 with syndrome $q=(q_1,\dots,q_n)\in\mathbb{R}^n$8;
• and the design enforces row-space nesting, $q=(q_1,\dots,q_n)\in\mathbb{R}^n$9.

The decoders are ordered and role-specific. On the write path, the DRAM receiver runs the $\gamma=(\gamma_1,\dots,\gamma_n)$0 check in detect-only mode as an L-ECC surrogate and triggers immediate retry on nonzero syndrome. On reads, O-ECC uses the same $\gamma=(\gamma_1,\dots,\gamma_n)$1 for SEC-DED under a bounded-fault constraint and corrects if and only if the syndrome maps to a single-bit error; DED-only cases are forwarded upward without correction. At the controller, $\gamma=(\gamma_1,\dots,\gamma_n)$2 supports SSC and DEC in parallel, followed by verification and at most one retry on DUE. The paper’s bounded-fault construction partitions the 288 columns into 18 contiguous 16-column regions and guarantees that any O-ECC miscorrection remains inside its originating 16-bit region, preserving one-symbol locality for the upper-layer SSC decoder.

This is an especially explicit EODM design because redundancy reuse is the central goal. The same 16-bit sub-redundancy $\gamma=(\gamma_1,\dots,\gamma_n)$3 is consumed on writes for link detection and on reads for in-device correction, while also forming part of the 32-bit system syndrome space. Quantitatively, Cerberus operates at 12.5% redundancy (32 bits per 256-bit block), versus an HBM4 baseline of 18.8% (48 bits/256). With that 12.5% overhead, the paper reports 100.000% correction of 16-bit clustered errors, 100.000% correction of In bank SE + Out bank SE, 100.000% correction of In bank SE + Out bank DE, and 99.999% CE-with-retry for Write link DQSE; the 15.6% configuration rounds to 100.000% for that case. Relative to HBM4, Cerberus reduces storage redundancy by 33.3%, improves IPC by 0.7% geomean, and reduces DRAM energy by 1.84%, while synthesizing to negligible DRAM-side area. In this context, decode-many means not many semantic outputs but many protection functions from one codeword.

6. Variants, misconceptions, and open questions

The surveyed literature shows that EODM is not a single formalism. In the Tensor Brain, encode-once refers to a global subsymbolic state and concept “DNA”; in OLEO, to offline news representation learning and cached embeddings; in ACEAPEX, to a compressed archive with self-contained blocks and a read-to-block index; in all-to-all encode, to a universal communication schedule whose coefficients vary with the target matrix; in distributed decode-forward, to source multicoding over multiple blocks; and in Cerberus, to a single ECC codeword whose redundancy is reused across three layers (Tresp et al., 2024, Liu et al., 2023, Shavidze, 17 Jun 2026, Wang et al., 2022, Lim et al., 2015, Kim et al., 4 May 2026). “Decode-many” is equally heterogeneous: symbolic labels, embodied reconstructions, ranking functions, region queries, simultaneous processor outputs, relay partial decoders, and layered syndrome checks all qualify.

Several limitations recur. In the Tensor Brain, the neurobiological mechanism for sampling initiation remains open; attention is described as a Heisenberg average rather than Bayesian conditioning; domain-wise exclusivity can be problematic; recall can alter engrams; and working memory limits raise scaling questions. In OLEO, content representation drift may require periodic re-encoding or adapters, personalization remains concentrated in $\gamma=(\gamma_1,\dots,\gamma_n)$4, and the evidence is centered on MIND. In ACEAPEX, encoding speed is approximately 340 MB/s on 50 GB, compression ratio is not best-in-class relative to zstd-19, the 16 KB block size is a measured sweet spot because smaller blocks hit an approximately 270 $\gamma=(\gamma_1,\dots,\gamma_n)$5s launch-overhead floor, and the demonstration is on FASTQ rather than coordinate-aware BAM/CRAM. The all-to-all encode results assume synchronous rounds, complete connectivity, and a $\gamma=(\gamma_1,\dots,\gamma_n)$6-port model, while Vandermonde and DFT optimizations require field-structure conditions such as distinct evaluation points and, for DFT, $\gamma=(\gamma_1,\dots,\gamma_n)$7. Distributed decode-forward relies on centralized source knowledge of codebooks and joint pmfs, and the paper identifies common-message broadcast and multiple unicast as harder open directions. Cerberus requires the compatibility constraint $\gamma=(\gamma_1,\dots,\gamma_n)$8, assumes that the device stores and returns the same 288-bit codeword with redundancy intact, and notes that wider-than-16-bit future correlated bursts may require reconstructing the code with a different symbol width.

Taken together, these works indicate that EODM is a reusable systems principle for amortizing a costly encoding stage across heterogeneous downstream decoding tasks. The technical content of the principle, however, is determined entirely by domain: embeddings and attention in cognitive models, frozen vectors in recommender systems, absolute-offset block codecs in genomics, universal schedules in collective communication, multicoding in relay networks, and row-space-nested parity in memory protection.