The takeaway up front

All four papers dropped on arXiv July 18 2026. None got any social media traction. None are 100B parameter model launches. Together they fix the three biggest problems holding back reasoning models right now: you don't need to pretrain from scratch, you don't need automatic verifiers to improve performance, and intermediate reasoning state no longer gets erased every token step.

You can retrofit every one of these changes onto an existing open model this week. For less than $10 total.

The core flaw in standard transformer decoding

Everyone has watched an LLM get half way through a hard math problem, forget a number it calculated three tokens earlier, and derail completely. No one had properly diagnosed why this happens until this week.

Autoregressive decoding works by throwing away almost everything after every single token. The only state that survives is the final layer hidden state, which gets compressed down into a single token embedding. All the rich intermediate computation that happened in layers 4 through 18? It gets discarded. Forever.

Every time the model outputs one word, it burns all of its working notes. This is not a training problem. This is an architectural defect built into every transformer released in the last 9 years.

T²MLR: Middle layer recurrence fixes working memory

This is the most important architecture change since attention itself. T²MLR does one very simple thing: it caches the hidden state from one single middle layer at step N, and injects it directly into the same layer at step N+1. Nothing else changes. No extra parameters. No full network recurrence.

That is the entire change.

The paper tested this on a 1.7B base transformer. They added this single connection, fine tuned for 1200 steps. GSM8K pass@1 went up 18 percentage points. MMLU went up 7.

You do not need to retrain the whole model. You do not need any new data. This is a one line change to your transformer forward pass.

Most remarkably: applying recurrence to the full network performed worse. Only applying it to layers 6-10 worked best. The middle layers are exactly where abstract intermediate reasoning state lives. No one noticed this before.

Benchmark results for T²MLR

All results are for identical parameter count, identical training data, identical evaluation protocol.

Configuration	GSM8K pass@1	MMLU 5 shot	Inference overhead
Base 1.7B Transformer	42.1	61.3	0%
Full layer recurrence	47.9	63.7	+22%
T²MLR layers 6-10 only	60.2	68.1	+3%

They did not add parameters. They did not clean training data. They just stopped throwing away the working notes.

$3 reasoning model adaptation

For the last 18 months every gain in reasoning models has come from reinforcement learning with verifiers. That works great for math and code. It does not work at all for anything where you cannot automatically check if the answer is right. Law. Medicine. Policy. Planning.

This paper demonstrates you do not need verifiers.

The procedure is trivial:

1. Take your existing good reasoning model
2. Run standard instruction tuning on it with 50k human written examples, no reasoning traces required
3. Merge the resulting model back with the original base using a 0.7 weight coefficient

That is it. Total compute cost: $2.87 at current spot prices.

It preserves all original reasoning capabilities. It does not make the model dumber at anything else. No one has ever published this result before. Everyone assumed you had to train reasoning traces. You don't.

Reasoning graphs break authorship obfuscation

All existing LLM detection dies when you run the output through one round of paraphrasing. Everyone knew this. No one had a working fix.

This paper shows that you do not detect LLM output from the words. You detect it from the structure of the reasoning. Every model has a consistent, identifiable signature in how it connects claims, what order it presents arguments, what steps it skips, what steps it repeats.

Paraphrasing changes every word. It does not change this graph structure.

Under paraphrase attack, standard Longformer detection dropped to 51% accuracy. The reasoning graph method stayed at 78%. Under back translation attack it stayed at 72%.

This is not a minor improvement. This means that obfuscation is effectively dead for any LLM that produces reasoned output.

RAPTOR: Temporal knowledge graph reasoning stops guessing

RL based TKG reasoning has been stuck for 3 years. Agents would wander randomly through the graph for 98% of training steps, almost never find the correct path, and never learn anything useful. Reward was so sparse most runs would diverge completely.

RAPTOR adds one single pretraining objective: before doing any RL, train the agent to just predict whether any given edge will eventually lead to the target node. That is all.

Training time dropped by 73%. Final hit@1 improved 21 percentage points across all standard ICEWS datasets. The agent stops walking down dead ends immediately.

This is not just for knowledge graphs. This same bias can be injected into any sequential reasoning agent.

The 5M reasoning corpus

All of this work landed the same day that SupraLabs dropped 5 million filtered reasoning traces on Huggingface. This is not scraped web garbage. Every entry has a full unmodified thought trace, user prompt, and final output from every major recent reasoning model including DeepSeek R1, Qwen 3.5 and Gemma 4.

This dataset did not exist 7 days ago. Before this the largest public reasoning corpus was 120k entries.

It is released under public domain. There are no usage restrictions.

What this changes

Right now every major lab is racing to train 100B+ reasoning models. Every single one of them is using standard transformer decoding.

You can take Llama 3.1 8B right now, add the T²MLR middle layer connection, run the $3 merge adaptation, fine tune on this corpus, and you will outperform every model released before July 2026. For about $150 total compute.

None of this is secret. All of the papers are public. Reference implementations for every change will be posted in the next two weeks.

Almost no one has noticed yet.

What comes next

We have crossed an inflection point. Reasoning performance is no longer bounded by parameter count. It is no longer bounded by training compute. It is now bounded almost entirely by architecture choices that no one was testing 6 months ago.

The next generation of models will not be bigger. They will just stop throwing away their notes.