GRAM: Transforming Recursive Latent Reasoning into a Generative Powerhouse

TL;DR

Future AI reasoning shouldn't just be deeper (more steps), it should be wider (exploring more possibilities). GRAM (Generative Recursive reAsoning Models) achieves this by turning deterministic internal loops into stochastic latent trajectories. This allow the model to discover multiple valid solutions to a single problem and scale performance at inference time by sampling parallel "trains of thought" instead of just thinking longer.

Context: This work moves beyond "Chain-of-Thought" (tokens) and prior "Recursive Models" (deterministic hidden states) to a fully probabilistic generative framework for internal reasoning.

The Bottleneck: Deterministic Thinking

Architectures like the Universal Transformer or Looped Transformer reuse the same weights to solve hard problems iteratively. While efficient, their fatal flaw is determinism. If a model's internal "refinement" path starts incorrectly, it is often trapped in a suboptimal trajectory with no way to backtrack or explore alternatives.

In tasks like N-Queens or Graph Coloring, where dozens of valid solutions exist, a deterministic model mode-collapses to a single path. This is the "Suboptimal Attractor" problem.

Methodology: Stochastic Guidance & Hierarchical Refinement

GRAM solves this by redefining the latent state update as a probabilistic transition.

1. The Stochastic Bridge

Instead of a simple $z_t=f(z_{t-1})$, GRAM uses: $z_t=u_t+{ϵ}_t,{ϵ}_t\sim \mathcal{N}(\mu (u_t),{\sigma }^2(u_t)I)$ The model learns a "Stochastic Guidance" signal (${ϵ}_t$) that nudges the reasoning process. This isn't just random noise; it's a learned distribution that explores the manifold of valid solutions.

2. Hierarchical Latent States

The model decouples computation into two speeds:

• Low-Level ($l$): High-frequency, deterministic refinement of fine-grained details.
• High-Level ($h$): Slower, stochastic transitions that steer the abstract "strategy" of the reasoning.

Figure 1: The GRAM Architecture. Stochasticity is injected at the high-level state, allowing the model to "jump" between different reasoning trajectories while the low-level loop performs the heavy lifting of constraint satisfaction.

A New Scaling Law: Depth vs. Width

The most groundbreaking aspect of GRAM is how it scales at test-time. Traditionally, we scale LLMs by generating more tokens or RRMs by running more iterations (Depth).

GRAM introduces Width Scaling:

• By sampling $N$ parallel latent trajectories and using a Latent Process Reward Model (LPRM) to pick the best one, GRAM achieves higher accuracy with lower latency than traditional sequential models.
• Efficiency Gain: On Sudoku-Extreme, GRAM with 20 parallel samples at 16 steps outperforms TRM with 320 sequential steps (97% vs 90.5%).

Figure 2: Performance Scaling. Notice how parallel sampling (Width) provides a massive horizontal boost, allowing the model to find solutions that sequential depth alone would miss.

Beyond Reasoning: Unconditional Generation

Because GRAM is a probabilistic generative model, it can generate data from scratch. When given a "blank" input, it "reasons" its way into creating complex, valid Sudoku boards or MNIST digits. Its validity rate on Sudoku generation (99.05%) crushes specialized discrete diffusion models (D3PM), despite having far fewer parameters.

Critical Analysis & Conclusion

Takeaway

GRAM proves that stochasticity is a feature, not a bug in reasoning. By framing reasoning as a latent-variable problem, it bridges the gap between structured constraint satisfaction and modern generative AI.

Limitations

• Training Complexity: Deep supervision and variational inference are more complex to implement than standard next-token prediction.
• GPU Memory: Backpropagating through many recursive steps remains memory-intensive, despite the use of truncated gradient techniques.

Future Outlook: Could we replace the "explicit" CoT of current LLMs with this "latent recursive" approach? GRAM suggests that the future of AI might involve models that "dream" up multiple solutions in a hidden space before committing to an answer.