PRISM: Parallel Residual Iterative Sequence Model

Generative sequence modeling faces a fundamental tension between the expressivity of Transformers and the efficiency of linear sequence models. Existing efficient architectures are theoretically bounded by shallow, single-step linear updates, while powerful iterative methods like Test-Time Training (TTT) break hardware parallelism due to two dimensions of serial dependency: token-level state reliance and step-level iteration loops. We propose PRISM (Parallel Residual Iterative Sequence Model) to resolve this tension. PRISM explicitly reconstructs the expressive gate × residual × direction iteration pattern of TTT in a parallelizable form. We employ a Write-Forget Decoupling strategy that isolates non-linearity within the injection operator. To bypass the serial dependency of explicit solvers, PRISM utilizes a two-stage proxy architecture: a short-convolution anchors the initial residual using local history energy, while a learned predictor estimates the refinement updates directly from the input. This design distills structural patterns associated with iterative correction into a parallelizable feedforward operator. Theoretically, we prove that this formulation achieves Rank-$L$ accumulation, structurally expanding the update manifold beyond the single-step Rank-$1$ bottleneck. Empirically, it achieves comparable performance to explicit optimization methods while achieving 174x higher throughput. Codes are available in \url{https://github.com/gpr-prism/prism/}.

Modern AI systems process sequences — text, user histories, sensor streams — by maintaining a compressed "memory" that summarizes everything seen so far. The dominant approach (Transformers) keeps a perfect record but becomes prohibitively expensive for long sequences, scaling quadratically with length. Efficient alternatives compress memory into a fixed-size matrix updated one step at a time, achieving linear cost — but each update can only modify one "direction" in memory (a Rank-1 update), limiting how much nuance can be captured per step. More expressive methods exist that perform multiple refinement steps per token, but they require each step to read the current memory state, creating a sequential bottleneck that makes training over 174 times slower. We introduce PRISM, which achieves the quality of multi-step refinement while maintaining the speed of simple one-step models. The key idea is to predict what the refinement steps would produce using only the local input context — without actually reading the memory state — so that the entire multi-step loop can be collapsed into a single parallel operation. In experiments on recommendation systems and language modeling, PRISM matches the accuracy of expensive iterative methods while running 174 times faster, and approaches Transformer-level quality at a fraction of the computational cost.