# Amazon's Plumbline finds silent bugs that a falling training loss hides

An Amazon team describes a set of checks that test each part of a language model training run against a trusted reference. Over two months, it found 61 problems across five new models, and about half raised no error at all.

- Category: Language models
- Readiness level: II (Benchmarked) on Science Underway's four-step scale, as proposed
- Published: 2026-11-14
- Editor: Stefan Perdal
- URL: https://scienceunderway.com/articles/amazon-s-plumbline-finds-silent-bugs-that-a-falling-training-loss-hides

## The study

Plumbline: When the Loss Lies, Validating LLM Training Correctly (preprint, not peer reviewed). DOI 10.48550/arxiv.2611.13393, arXiv 2611.13393. https://arxiv.org/abs/2611.13393

## At a glance

- What it shows: When teams train large AI language models, many software faults cause no error. The training still looks healthy. Amazon researchers built a system of small, separate checks that found 61 such problems in newly released models, and 32 of them were silent.
- What it does not show: It does not show how many faults the system misses, how much time or money it saves, or whether fixing these faults makes the final models better. No other tool was compared.
- Why it matters: A single hidden fault can waste weeks of costly computing or produce a weaker model without anyone noticing. Checking each part before a long run is cheaper than finding the fault afterwards.

## What the study shows

Teams that adapt a released language model usually train it with open-source software, called training frameworks. These frameworks split the model across many graphics processors (GPUs). A fault can sit in the data handling, the saved files, the maths of each update or the network. Many such faults do not crash anything. The main health signal, the loss (a running score of how wrong the model is), keeps falling as normal.

The authors built Plumbline to test each part of a run on its own. Each check compares the framework's output with a reference the framework did not produce. Examples include the model maker's official chat template and original weights, or a slow, high-precision recalculation on an ordinary processor. Where an exact match is impossible, the check allows only a margin set above the measured random variation between runs.

The checks work at three levels. Some cover each stage, from preparing data to saving, resuming and exporting the model. Some test one training step under every supported setting. Others run short full training runs. A coding agent, an AI system that writes and runs code, chooses and runs the checks. A human reviewer approves its plans and confirms every problem.

The authors report results from September to October 2026. They scanned 5 newly released models on 3 frameworks, 13 combinations in all. The scan found 61 problems, and 32 were silent. The part-by-part checks caught 29 of those 32 first. At least 16 silent problems sat in runs that passed the short full-run checks. Of the 61, 42 are fixed or reported to the framework developers, and 8 were first raised by the authors.

The examples are concrete. In one model, loading the checkpoint (the saved weights) turned some weight tables on their side. The run started far worse than it should, yet its loss still fell and it passed the full-run checks. In another, the data setup never taught the model the token that ends a reply, so it was not trained to stop. In a third, a resumed run forgot how many update steps it had taken.

The same checks were used to trace each failure to its cause. The authors say all 61 were located, and 50 were traced down to a specific line of code. In one case, a crash on eight machines was explained using one machine for about half a node-hour, meaning one machine running for about thirty minutes. This is a preprint and has not been peer reviewed.

## Our reading

In our reading, the central message is simple and useful: a falling loss is not proof that training is correct. The paper backs this with specific, checkable cases rather than general warnings. The transposed weights example is striking. The run started from a much worse point than a correct load would give, and the run-level checks still passed it, because they judge stability, not the value of the loss.

The design idea is sound engineering. Each check answers one narrow question against a reference that the code under test did not produce. That makes a failed check point to a likely location, and it lets the same checks be reused when hunting for a cause. A practical example: a team about to fine-tune a newly released model could run the data check first. It would learn, before booking any GPUs, that its setup drops the end-of-reply token.

The evidence is a count of problems the authors found in their own system, written by the system's builders. There is no test of how many faults it misses, no false alarm rate and no comparison with other tools. On our four-level readiness scale, we rate this I, Lab only. No public benchmark result exists and the code is not yet released. Amazon's production use is stated by its own authors without usage detail, so we do not count it as level IV evidence.

The rest of the article (what it means, limits, what to watch) is free for members: https://scienceunderway.com/articles/amazon-s-plumbline-finds-silent-bugs-that-a-falling-training-loss-hides

## How this was made

An AI model read the study and wrote this article in the structure Science Underway uses. An editor reviewed it and approved it for publication. Check the original study before you rely on the details.

---
Source: Science Underway, https://scienceunderway.com/. Please link to the article when you cite it.
