latent-chain-of-thought

name	latent-chain-of-thought
title	Latent Chain-of-Thought as Planning: Decoupling Reasoning from Verbalization
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2601.21358
keywords	["Latent Reasoning","Planning","Decoupled Verbalization","EMA Aggregation"]
description	Improve reasoning quality by decoupling reasoning from verbalization. Planner generates deterministic latent trajectories while Decoder grounds them to text. Enables dynamic termination, better Pass@k scaling, and interpretable intermediate states.

PLaT: Planning with Latent Thoughts

Problem

Standard chain-of-thought requires discrete token commitments at each step, limiting solution space exploration. Models must balance reasoning coherence with early commitments that prune future options.

Fixed-length reasoning doesn't adapt to problem difficulty. Interpretability of intermediate reasoning is limited.

Core Concept

PLaT decouples planning (latent trajectory) from verbalization (decoder). The Planner evolves latent state representations without committing to tokens. The Decoder optionally converts latent states to text for inspection or final answers.

This maintains superposition of multiple reasoning paths longer than token-level approaches, enables dynamic termination, and supports Pass@k exploration.

Architecture Overview

• Planner: Generates deterministic latent trajectories in continuous space
• Decoder: Grounds latent plans into text when needed
• EMA Aggregation: Stabilizes planning states across reasoning steps
• Lazy Decoding: Efficient inference checking only first token for termination
• Supervised Fine-Tuning: Aligns latent representations with reasoning steps
• Decoupled GRPO: Refines Decoder verbalization while freezing Planner

Implementation

Step 1: Build Latent Planner

Create deterministic planning trajectory in continuous embedding space.

class LatentPlanner(nn.Module):
    def __init__(self, hidden_dim=1024, num_latent_steps=32):
        super().__init__()
        self.hidden_dim = hidden_dim
        self.num_latent_steps = num_latent_steps
        self.planning_mlp = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim * 2),
            nn.ReLU(),
            nn.Linear(hidden_dim * 2, hidden_dim)
        )

    def forward(self, input_embedding):
        """Generate planning trajectory from input."""
        latent_states = []
        current_state = input_embedding

         step  (.num_latent_steps):
            
            next_state = .planning_mlp(current_state)
            latent_states.append(next_state)
            current_state = next_state

         latent_states