Liquid AI ships Antidoom: fixes reasoning models' "doom loop" problem by retraining just one token, now open-source
- On July 7, 2026, Liquid AI released Antidoom, which uses a method called Final Token Preference Optimization (FTPO) to specifically fix the "doom loop" in AI reasoning models — where a model repeats the same phrase (e.g. "Wait, let me reconsider...") over and over until it burns through its context window.
- On an early LFM2.5-2.6B checkpoint, the doom-loop rate on harder math / code problems dropped from 10.2% to 1.4%; on Qwen3.5-4B, it fell from 22.9% to 1% under greedy sampling.
- The method trains only the single token that triggers the loop, nudging the model toward a more coherent alternative at that spot while barely disturbing the rest of its output distribution.
- Doom loops arise from three mechanisms working together: over-trained high-frequency words (the, So, Wait, etc.) get picked as a fallback when the model is uncertain, repeated context drives the loop probability toward 1, and low-temperature greedy sampling leaves the loop no way out.
- The full training / detection / generation code is open-sourced on GitHub (Liquid4All/antidoom), with a complete hyperparameter selection guide in the README, and support for both NVIDIA/CUDA and the AMD Instinct MI series (ROCm).
AI can get stuck like a broken record
On July 7, 2026, Liquid AI released Antidoom, a training method built specifically to fix the "doom loop" in AI reasoning models, and open-sourced all of the code on GitHub.
The doom loop is a very common failure mode for reasoning models: the model spits out a short bit of text, say "Wait, let me reconsider...", then repeats that line again and again until the context window is full — yet the answer never shows up. The smaller the reasoning model, the more prone it is, especially on long chains of thought and hard problems.
Let me double-check the derivation in step two of this problem.
Wait, let me reconsider...
Wait, let me reconsider...
Wait, let me reconsider...
Wait, let me reconsider...
Wait, let me recons
(the context window fills up, and the answer never appears)
Why the old fixes treat the symptom, not the cause
Before Antidoom, there were usually two ways to fight doom loops, each with its own weakness.
The first is adding repetition_penalty at inference time to temporarily lower the probability of words that have already appeared. It's like a band-aid — no retraining needed — but it penalizes indiscriminately and can drag down the quality of normal output too. The second is reinforcement learning (RL), which can target the loop directly, but at the cost of carefully designing a reward signal and running expensive online rollout sampling.
| Method | How it works | Cost | Side effects |
|---|---|---|---|
| repetition_penalty | Temporarily down-weights repeated words at inference | Low, no training | Can hurt normal output quality |
| Reinforcement learning (RL) | Retrains the model with a reward signal | High — reward tuning plus online sampling | A bad reward design sends it off course |
| Antidoom | Trains only the single token where the loop starts | Low — LoRA, a few hours on one GPU | Almost no disturbance to the rest of the output |
Change one token, leave everything else untouched
Antidoom shrinks the fix to the absolute minimum.
It first finds the single token where the doom loop begins, and trains the model only at that spot to pick a more coherent alternative — the probability distribution over the rest of the vocabulary stays essentially the same. The whole model's output habits stay put; only the seam that triggers the loop gets a precise patch.