The mistakes an LLM will never catch itself making

The dangerous thing about a modern language model translating fiction is not that it makes mistakes. Every translator makes mistakes. The dangerous thing is that its mistakes read beautifully.

A human translator who is unsure of a word leaves a trace: an awkward phrase, a hedge, a footnote. A language model does not get unsure. It produces the same confident, fluent prose whether it is right or wrong, and it produces it just as smoothly for the sentence it botched as for the sentence it nailed. The output gives you no signal about where to look. That is what makes the errors expensive, and it is why we do not trust the model to check its own work.

The errors that hide in fluent prose

The failures worth worrying about are not the ones that produce garbled text. Garbled text is easy to catch. The costly failures are the ones that leave the prose perfectly readable and change what it says. A few representative classes, all illustrative rather than drawn from any specific incident:

A number quietly changes. A distance becomes a slightly rounder distance. A character’s age shifts by a year. A date moves. A quantity is off. Nothing about the sentence signals the change, because the sentence is still a good sentence.

A named term drifts across chapters. A place, a title, an organization gets rendered one way in chapter three, a second way in chapter forty, and a third way in chapter ninety. Each rendering is defensible in isolation. Read in isolation is exactly how a model translating one chapter at a time sees them, so nothing forces them to agree.

A name fractures under grammar. In morphologically rich languages, a single name takes many forms as it moves through cases and inflections. In Polish, Russian, or Turkish, the same person can surface as what looks like several different people, and unless something knows those forms belong to one character, the translation can quietly split one person into a small crowd.

A unit goes ambiguous. A measurement gets carried across without being resolved, or is handled in a way that leaves the reader guessing what scale is meant.

None of these announce themselves. All of them survive a fluent read.

Why the model cannot catch them

The natural question is why you cannot simply ask the model to review its own translation and catch these. The answer is in what the model is and is not built to do.

It is optimized for fluency and plausibility. Its whole training pushes it toward output that reads well and sounds likely, and a changed number reads just as well as the correct one. Plausibility is no defense here, because the wrong answer is usually plausible.

It is confident when it is wrong. There is no internal alarm that rings on the sentences it got wrong, because from the inside those sentences feel identical to the ones it got right. Asking it to find its own errors asks it to distinguish two things that feel the same to it.

It has no reliable memory of what it wrote hundreds of pages ago. Consistency across a long book is a question about the whole book, and no single pass over a single chapter has the whole book in view. The model cannot check chapter ninety against chapter three, because when it is translating chapter ninety, chapter three is not in front of it in any dependable form.

Put together: the model will not audit itself, not because it is lazy, but because self-audit requires exactly the capabilities it lacks. So we stopped asking it to.

Rules do not get tired

What we do instead is pair probabilistic generation with deterministic verification. The model does the creative rendering, the part that genuinely needs a language model. Then rules check the result.

Rules are good at precisely the things the model is bad at. A rule that enforces an agreed glossary of terms does not get tired on chapter ninety and let a new spelling through. A rule that checks numbers and units does not find a changed distance more plausible than the original. A rule that checks consistency across chapters holds the whole book in view by construction, because that is what it was built to do. Rules do not hallucinate, do not get bored, and flag exactly the drift that a careful human editor would otherwise spend hours hunting by hand.

This is what we mean when we call the system neuro-symbolic. The neural part is the model, doing the fluent, creative work of turning one language into another. The symbolic part is a layer of deterministic rules that keeps it honest. Neither half is sufficient. A pure model translates fluently and drifts. A pure rule system cannot translate a sentence at all. The value is in the seam between them, where a confident wrong answer gets caught by something that was never trying to be fluent, only correct.

The reason to structure it this way is not philosophical purity. It is that fiction is long, and a long book gives a fluent model hundreds of chances to be confidently wrong in ways no reader would notice until it is too late. This is the layer of the translation pipeline that runs at scale in Tellura: the model renders, the rules verify, and the errors that read beautifully do not survive the second step.