Encode-Think-Decode (ETD) Paradigm

• Encode-Think-Decode (ETD) is a structured approach that transforms input data into latent representations, applies recursive reasoning, and decodes outputs to achieve efficient, multi-step inference.
• The paradigm partitions models into distinct encoder, reasoning (think), and decoder modules, enabling targeted refinement without increasing the parameter count.
• Adaptive computation in ETD dynamically allocates recursive iterations per token, enhancing performance on complex tasks while maintaining computational efficiency.

The Encode-Think-Decode (ETD) paradigm specifies a structured approach for information processing, emphasizing the successive stages of encoding input data into a latent representation, recursive reasoning within that space, and finally decoding the refined representation to produce the output. This sequence has been applied in diverse fields including sensory neuroscience, mass spectrometry, reinforcement learning, computational neuroscience, brain-computer interfaces, and, most recently, LLMs. Central to ETD is the notion that substantial analytic power can be gained by explicitly separating and optimizing each stage, particularly recursive reasoning on a targeted subset of layers or modules.

1. Foundational Concepts and Definition

ETD arose from interpretability studies and practical algorithm design as an architectural motif facilitating advanced reasoning. The process can be defined by three sequential components:

• Encode: Input data are mapped into an internal, often high-dimensional, latent representation via an encoder. For LLMs, this typically involves the initial layers of a transformer network; in sensory systems, encoding translates analog inputs into spiking patterns or intermediate feature vectors.
• Think: A core module, termed the "reasoning block," is recursively applied to the encoded representation, permitting multiple rounds of internal refinement. This recursive computation amplifies the model's ability to capture long-range dependencies, complex relational structures, and multi-step reasoning traces.
• Decode: The refined latent state is mapped back into the output domain—language tokens, motor commands, predicted spectra, or behavioral actions—via a decoder component.

The ETD formalism is typically implemented by partitioning a multi-layered architecture, such as a transformer, into contiguous blocks designated for encoding, reasoning (with iteration count $k$), and decoding. For example, a configuration "^^^^1^^^^" delineates 7 encoder layers, 4 layers in the recursive reasoning block executed $k$ times, and 5 decoder layers.

2. Technical Implementation

The central innovation of ETD is recursive reasoning over a small subset of layers within the overall architecture, without changing the number of parameters or introducing new hyperparameters. In transformer-based LLMs, the ETD process is mathematically represented by a partitioned residual sum over layers:

$$x^{(L)} = x^{(0)} \;+\; \sum_{l=0}^{N_E-1} f(x^{(l)}, \theta^{(l)})\;+\; \sum_{j=1}^k \sum_{l=N_E}^{N_E+N_T-1} f(x^{(l + (j-1)N_T)}, \theta^{(l)})\;+\; \sum_{l=N_E + N_T k}^{L-1} f(x^{(l)}, \theta^{(l)})$$

where $E$ is the encoder, $T$ the recursive block of $N_T$ layers repeated $k$ times, and $D$ the decoder. The boundaries between blocks are automatically identified using algorithms such as Kneedle, which locates the inflection point in the angular change of hidden states.

At inference, input is encoded via $E$, then subjected to $k$ recursive applications of $T$, followed by output generation through $D$. This process enables calculated allocation of computational resources: reasoning-intensive tokens are given more recursive depth, while simple cases terminate early.

3. Recursive Latent Reasoning and Adaptive Depth

ETD introduces adaptive computation by dynamically varying the number of recursive iterations per token. A simple router, implemented as a linear projection with a sigmoid activation, outputs a halting score $w_t$ on each iteration. The cumulative halting score $H_t = \sum_{j=1}^t w_j$ is tracked, and recursion is terminated for a token when $H_t$ reaches a threshold near 1 (e.g., $1 - \varepsilon$). This mechanism, akin to Adaptive Computation Time (ACT), confers two core advantages:

• Reasoning effort is matched to token complexity, improving both accuracy and efficiency.
• In multi-token contexts (e.g., chain-of-thought language generation), each token can be routed through a unique number of reasoning steps.

Tasks requiring substantial planning or multi-step inference (e.g., DROP, OpenBookQA) benefit markedly, with empirical improvements observed in both accuracy and computational efficiency.

4. Empirical Results and Performance Analysis

The application of ETD to LLMs yields substantial accuracy gains on diverse reasoning benchmarks. For instance, an OLMo-2 1B base model with ETD achieves:

• +28.4% relative accuracy on GSM8K (math word problems)
• +36% relative accuracy on MATH (formal math reasoning)

These improvements are realized on top of the baseline model, where ETD with $k=1$ (no recursion) represents standard inference. Importantly, tasks that primarily emphasize memorization or simple factual recall display negligible gains, demonstrating the specificity of recursive latent reasoning to inference-driven tasks.

The approach generalizes across benchmarks, including Commonsense Reasoning, Reading Comprehension, and multi-disciplinary tasks, indicating that recursive refinement unlocks emergent reasoning capacity inaccessible to non-recursive architectures.

5. Architectural Impact and Efficiency

A distinguishing feature of ETD is its non-intrusive integration within extant architectures. The following properties are preserved:

• Parameter count and overall layer composition remain unchanged.
• Original hyperparameters are retained.
• Training data composition is unaltered; recursive reasoning can be incorporated by a retroactive mid-training step.

By focusing recursive computation on the layers empirically shown to concentrate reasoning dynamics (as revealed by interpretability studies), ETD eliminates overhead commonly associated with scaling either model size or input sequence length. The method effectively reuses existing circuit components, functioning as an inference-time amplifier for reasoning without external augmentation.

6. Theoretical and Future Directions

The ETD mechanism illustrates how recursive latent reasoning—either via fixed or adaptive depth—enhances model interpretability, robustness, and accuracy. The architecture supports extensions to multimodal domains and more sophisticated routing strategies. The paradigm further invites analysis of how recursive computation interacts with representational circuits, potentially illuminating emergent properties of deep reasoning within neural networks.

A plausible implication is that future LLMs, and broadly, computational systems, may benefit from architecturally embedded mechanisms for adaptive reasoning depth, rather than relying solely on brute-force scaling of parameters or data. Such mechanisms better emulate resource allocation strategies observed in biological reasoning and may approach human-like efficiency and flexibility.

7. Summary Table: ETD Architectural Partitioning

Block	Role in ETD Framework	Typical Layer Count (OLMo-2 1B)
Encoder (E)	Input conversion	7
Think (T)	Recursive reasoning	4 (repeated k times)
Decoder (D)	Output generation	5

The partitioning of layers via measured angular changes in hidden states ensures that recursive computation is applied exclusively to reasoning-relevant layers, optimizing both performance and resource usage.

---

Encode-Think-Decode, as formalized in transformer models, provides a principled, empirically validated path toward scalable reasoning. By orchestrating recursive latent refinement within targeted blocks, ETD simultaneously augments analytic capacity and preserves architectural parsimony, representing a significant advance in algorithmically tractable machine reasoning (Koishekenov et al., 8 Oct 2025).