Lapras replaces CoT with latent reasoning: up to +10.79% F1 with 23.9x fewer tokens

The authors of Lapras (Latent Post-trained Reasoning Across Series) propose dropping text-based chain-of-thought reasoning in models that analyze time series. In tests on four TSLM backbones and five time series question-answering benchmarks, average F1 rose by up to 10.79% relative to explicit Chain-of-Thought. The model also generates 23.9x fewer tokens. The work is published on arXiv (cs.CL).

Where CoT breaks down on time series

Time Series Language Models take a continuous signal as input (sensor readings, ECG, stock quotes) and answer questions in natural language. The standard approach is CoT: the model first describes step by step what it sees in the series, then draws a conclusion.

This scheme has a weak spot. A high-dimensional continuous representation has to be compressed into discrete language tokens. According to the authors, the model may miss a significant pattern or describe it inaccurately at this stage. Later steps build on the description already written, so the error carries forward. The result is a plausible-sounding explanation that contradicts the original signal. Such answers are the hardest to catch because they look convincing.

How Lapras works

Lapras is a post-training stage. The model reasons through a chain of continuous thoughts in a joint space of time series and language, and writes text only for the final answer. The intermediate steps stay as hidden states and are not translated into words.

Training is built on teacher-student self-distillation:

• The teacher is trained on reference CoT traces and reasons explicitly, in text.
• The student aligns its hidden states with the teacher's at the answer stage.
• The reasoning ability transfers into the student's latent computation, so it no longer has to generate long descriptions.

Interpretability is a separate point. Lapras's continuous thoughts can be decoded into readable reasoning traces with standard language decoding. The text explanation does not disappear: it can be produced on request rather than generated every time.

What the experiments showed

The authors tested the method on four different TSLM backbones and five time series QA benchmarks. Summary from the abstract:

• Gain in average F1 over explicit CoT: up to 10.79%.
• Reduction in generated tokens: 23.9x.
• Four backbones and five benchmarks tested.
• Latent reasoning can be decoded into text without a separate architecture.

The abstract does not name the models, break results down by task, or give latency figures in milliseconds. "Up to 10.79%" is a maximum, not an average across all configurations, and it is unclear whether it means percentage points or relative growth. The figure should be checked against the full text and tables. Comparability with other latent approaches should also be verified in the paper itself.

Who can use this in practice

A 23.9x reduction in tokens directly lowers inference cost and latency. For monitoring equipment, medical signals, or financial series, where requests arrive as a stream, this may matter more than the metric gain. Short answers are cheaper to generate, and fewer text steps leave fewer places for errors to accumulate.

Teams building TSLM products should watch two things. First, the teacher needs high-quality CoT traces: the scheme does not work without them. Second, decoded latent thoughts should be checked for consistency with the signal. A readable trace does not mean a correct one. Before using the method in critical domains, run it on your own data and compare it with ordinary CoT on both F1 and explanation quality.