---
title: "ReLAT Fixes AI's Hidden Reasoning Flaw and Cuts Token Usage by 84%"
subtitle: "ReLAT uses a self-supervised reconstruction loop to verify latent reasoning states at test time, pushing Qwen3-8B from 56.7% to 73.3% on AIME 2024"
url: "https://alphasignal.ai/news/relat-fixes-ai-s-hidden-reasoning-flaw-and-cuts-token-usage-by-84"
author: "AlphaSignal Newsroom"
author_url: "https://alphasignal.ai/editorial-team"
company: "AlphaSignal"
company_url: "https://alphasignal.ai/company/alphasignal"
published: "2026-06-04T00:00:00.000Z"
updated: "2026-06-12T02:00:22.723Z"
type: "Paper"
topics:
  - "Reasoning"
  - "Post Training"
subtopics:
  - "Test Time Compute"
  - "Math Reasoning"
  - "Fine Tuning"
upvotes: 1470
source_url: "https://arxiv.org/abs/2606.06252"
comments: 0
truncated: true
---

# ReLAT Fixes AI's Hidden Reasoning Flaw and Cuts Token Usage by 84%

> ReLAT uses a self-supervised reconstruction loop to verify latent reasoning states at test time, pushing Qwen3-8B from 56.7% to 73.3% on AIME 2024

A new paper introduces [ReLAT (Reconstruction-Guided Latent Reasoning At Test Time)](https://arxiv.org/abs/2606.06252), a self-supervised method that addresses a fundamental blind spot in how large language models reason in latent space. The core problem it solves is deceptively simple: when a model thinks in continuous, non-text representations, there is no way to check whether those internal thoughts still faithfully capture the original question. ReLAT closes that gap by forcing the model to reconstruct the question from its own latent thoughts before generating an answer.

## The Open-Loop Problem in Latent Reasoning

To understand why this matters, you need to know what latent reasoning is. Traditional chain-of-thought reasoning externalizes every intermediate step as text, which is readable and verifiable but token-expensive. A growing line of work instead keeps those intermediate steps as continuous vector representations, or KV-cache states, passing them directly between reasoning stages without ever decoding them into words. This is faster and richer, but it creates a new problem.

Latent reasoning operates in an open loop: the intermediate state is produced and consumed without any check that it still represents the query it was derived from. In text-based reasoning, a dropped constraint is visibly wrong. In latent reasoning, an opaque latent state that drops the same constraint looks no different from a faithful one, and is consumed by downstream computation as if it were reliable. 

![Framework comparison between Open-Loop Latent Collaboration and ReLAT's closed-loop reconstruction-guided approach](https://arxiv.org/html/2606.06252v1/x1.png)

To close this loop, we need a way to test whether an opaque latent state still preserves the information needed to specify its original query. The key observation is that the query itself is the natural reference for this test. If a latent state is a faithful representation of the question, the question should be recoverable from it. If not, the latent state has lost task-relevant information.

## How ReLAT Works

ReLAT operationalizes this idea as a differentiable cycle: **Question → Latent Thought → Question**. Before generating any answer, the model runs this loop and minimizes the reconstruction loss through the latent thought using temporary LoRA adapters (low-rank weight updates that are cheap to compute and discarded after each example). Here is the step-by-step procedure:

_Preview only. Full text requires an AlphaSignal Pro account._

## Sources

- [Closing the Loop on Latent Reasoning via Test-Time Reconstruction (arXiv)](https://arxiv.org/abs/2606.06252)
- [ReLAT Full Paper HTML](https://arxiv.org/html/2606.06252)
- [Test-time training could lead to LLMs that are better at complex reasoning (TechXplore)](https://techxplore.com/news/2025-07-llms-complex.html)