Scaling Laws for Latent Reasoning: How Test-Time Compute Tracks Circuit Depth

A recurrent-depth language model spends test-time compute by iterating a weight-shared block $T$ times, reasoning in latent space rather than emitting tokens. We show that this depth axis obeys a mechanistic scaling law: latent accuracy is the cumulative distribution function of a task's circuit depth, discounted by a per-step reliability that grows with model size $N$. The law makes three falsifiable predictions: (i) accuracy saturates in $\log T$, (ii) the iterations required grow linearly with reasoning depth, and (iii) the value of additional computation is proportional to the serial depth it advances. We verify these predictions on a compute-optimal ladder trained from scratch ($19$M–$121$M non-embedding parameters) across three reasoning domains. Fitting the law on smaller models predicts the entire depth-accuracy curve of the held-out largest model ($R^2=0.93$), with the deeper of two depths requiring more iterations in $461$ of $465$ untied comparisons. The released Huginn-$3.5$B follows the same saturating law $29\times$ beyond our ladder on GSM8K, ProsQA, and SVAMP ($R^2\ge 0.99$), while GSM8K accuracy decays geometrically with gold-solution depth ($R^2=0.96$). Continuous-thought positions provide substantially less accuracy gain per unit of compute than recurrent depth, and Coconut does not out-scale CoT on public ProsQA. Optimizing the law yields an inference-time analogue of the Chinchilla rule for allocating compute between model size and reasoning depth. Across these settings, test-time compute scales when it advances the serial depth required by the task, establishing circuit depth as the relevant unit of latent computation.