The test sentence was deliberately ordinary. A Spanish source string from a consumer-electronics warranty: "No devuelva el producto a la tienda; el reembolso no se procesará sin el comprobante de compra." Elin, a localization PM at a mid-size language-service provider, was running a bake-off. Two engines, one segment, target English, the same coffee-stained Tuesday. She fed the string to the production neural MT engine wired into the translation-management system, the platform that routes files and pre-populates segments, and it returned: "Do not return the product to the store; the refund will not be processed without the proof of purchase." Faithful. Slightly stiff, the article in "the proof of purchase" a touch literal, but every clause present, both negations intact, the meaning a mirror of the source. Then she pasted the same Spanish into a general chat LLM with a friendly prompt asking it to translate naturally for a US audience. It returned: "Please keep your receipt handy: returns are quick and easy at any store location, and refunds are processed within 3 to 5 business days." Read that again. It is gorgeous. It is warm, on-brand, the kind of sentence a senior copywriter would be proud of. It is also a near-total fabrication. The source told the customer not to return the product to the store; the LLM invited them to. The source warned that no refund happens without proof of purchase; the LLM promised a three-to-five-day refund window that exists nowhere in the original. The two machines failed in completely different ways, and that difference, the signature of how each kind of engine breaks, is the most useful thing a working linguist can learn this year. This lesson is about why neural MT and LLM translation are built differently, fail differently, and have to be read differently, and why the LLM's fluency is exactly what makes its errors the harder ones to catch.

Two Engines, One Screen, Two Different Crimes

Set the two outputs side by side and the pattern is not subtle once you know to look for it. Both are grammatical. Both read like a competent native speaker wrote them. To a tired eye skimming for flow at five thousand words a day, both pass. But the crimes underneath are different in kind, not just in degree, and that is the whole point.

The neural MT engine committed a small crime of stiffness. "The proof of purchase" with that extra article is a fingerprint: it is the engine transferring the Spanish structure a little too literally, a fluency wobble that an experienced post-editor smooths in two seconds. The meaning, though, is intact. Every clause in the source survived the crossing. If this had shipped unedited, a reader would understand exactly what the manufacturer wanted them to understand. The error is cosmetic.

The LLM committed a large crime of invention. It did not mistranslate the source so much as replace it. It read a terse, negative, slightly unfriendly warranty notice, decided that was not the kind of thing a helpful US brand would say, and wrote the sentence it imagined the brand would have wanted, complete with a refund timeline it conjured from nothing. The prose is better than the neural MT output by every fluency measure. The translation is catastrophically worse, because it is not a translation at all. It is a confident, well-dressed lie about what the source says.

Neural MT fails by staying too close to the source and losing fidelity in the details. An LLM fails by drifting away from the source and replacing it with something more pleasant. The first crime is visible; the second wears a disguise.

Hold that contrast. Everything in this lesson hangs off it. To understand why the two engines break in such different ways, you have to understand that they were built to do two different things, and translation means something different to each of them.

How Neural MT Is Actually Built

Let us define the terms cleanly, because the rest of the lesson leans on them. Machine translation (MT) is the umbrella term for any system that converts text from a source language to a target language with no human writing the words. Neural machine translation (NMT) is the specific, dominant flavor that has run high-volume localization pipelines since roughly 2016: a neural network, a layered web of numerical weights tuned by training, built and trained for one task and one task only, which is to translate.

The phrase that matters here is trained on parallel corpora. A parallel corpus is a giant collection of sentence pairs: a sentence in the source language sitting next to its human translation in the target language, millions upon millions of such pairs. Training is the process of showing the network those pairs over and over and nudging its internal weights until, given a source sentence it has never seen, it produces a target sentence that resembles what a human translator would have produced. The engine is not memorizing translations. It is learning the statistical shape of how one language maps onto another, distilled from all those examples.

The classic NMT architecture is called encoder-decoder, and the name describes the machine honestly. The encoder reads the source segment and compresses its meaning into a dense numerical representation, a list of numbers that captures, in the engine's internal language, what the sentence is about. The decoder then takes that representation and generates the target sentence one piece at a time, each piece chosen to be the most probable continuation given the source meaning and the target words produced so far. Encode the source, decode the target. That is the entire ceremony.

What Segment-Bound Really Means

Here is the single most important structural fact about a classic NMT engine: it is segment-bound. It translates one segment, usually one sentence, at a time, in isolation, and then forgets it ever existed before moving to the next. A segment is the unit your CAT tool, the computer-assisted translation environment where you live, breaks text into: typically a sentence, sometimes a heading or a list item. The NMT engine sees that one segment, encodes it, decodes a target, and moves on with no memory of the segment before or any awareness of the segment after.

This narrowness is not a flaw the vendors are racing to fix. It is the engine's defining trait, and it cuts both ways. On the upside, segment-bound translation is fast, cheap at industrial scale, and predictable. The engine does exactly one well-defined thing. It cannot wander off topic because it has no broader topic to wander into. On the downside, it is blind to anything outside the current sentence. If segment four uses a pronoun whose gender was established in segment two, the engine cannot know, because segment two is gone. If a term was translated one way in segment one, nothing forces consistency in segment fifty. The engine has no context window, no running memory of the document. Each sentence is a fresh start and a fresh chance to drift.

The Narrow Specialist and Its Failure Signature

Picture the NMT engine as a brilliant, literal-minded specialist who has translated ten million sentences and will translate yours the way the statistics say a sentence like yours is usually translated, then immediately forget your sentence. It does not chat. It does not reason about instructions, because you cannot give it instructions; you give it a source segment and it gives you a target segment, full stop. It does not summarize, expand, or improve. It transfers. Because it is anchored hard to the input and optimizes for the most probable faithful-looking output, its errors cluster in a recognizable, almost diagnosable set:

• Mistranslation by drift. The engine lands on a target sequence that is highly probable but subtly off: a dropped negation because "not" carries little statistical weight and the fluent path skips it, a corrupted number because 2.5 mg and 25 mg are both plausible dosages to a pattern-matcher, a flattened nuance where a precise source distinction collapses into a common near-synonym.
• Omission. A clause, a qualifier, or a whole phrase simply does not appear in the target, because the engine found a fluent path that skipped it. The output is complete and grammatical and missing part of the source's meaning, and nothing on the screen flags the loss.
• Terminology drift. The client approved one specific term in the termbase, the controlled glossary of approved terms, and the engine, trained on general parallel text, prefers a more common synonym and substitutes it segment after segment.
• Hallucination on thin input. Fed a fragment, a heading, garbled source, or a list item with no context, the engine generates plausible target text that corresponds to nothing in the source. It abhors a vacuum and fills it.

The through-line, and the reason these failures are dangerous at all, is that every one of them produces output that reads correctly. But notice the shape of the danger: the NMT engine fails at the source. It mishandles something that is actually in the segment in front of it. The error is always anchored to a real input. That anchoring is what makes NMT errors, for all their menace, comparatively findable. You can check the output against the source segment, clause by clause, number by number, and the discrepancy is right there. The engine did not leave the building. It just stumbled inside it.

How an LLM Translates, and Why Its Nature Is Different

A large language model (LLM) is a fundamentally different animal, and the difference is not a tuning detail. It is a difference in what the machine was built to do. An LLM is a general-purpose text-prediction system trained on an enormous, broad corpus of human writing, code, conversation, and documents from across every domain, with one core objective: predict the next token given everything before it. A token is the small unit of text the model works in, roughly a word or a word-piece; the model reads a stream of tokens and predicts the most likely next one, then the next, building text one token at a time.

Read that objective carefully, because everything follows from it. The LLM was not built to translate. It was built to continue text plausibly. Translation is one of countless things it can do, and it can do it for two reasons: translation examples are well represented in its vast training data, and producing plausible next tokens in another language is, mechanically, just another flavor of text continuation. When you ask an LLM to translate, you are not invoking a dedicated translation engine. You are giving a generalist a prompt, a natural-language instruction, that asks it to produce, as its plausible continuation, a translation of some text. It improvises a specialist task out of general competence.

Prompt-Driven and Context-Aware

Two structural features flow directly from this and set the LLM apart from segment-bound NMT. First, the LLM is prompt-driven. It does not just receive a source segment; it receives instructions in plain language, and it tries to follow all of them. "Translate this," "make it sound natural for a US audience," "keep it under 60 characters," "use a friendly tone," "match our brand voice." This is power and peril in one. You can steer an LLM in ways you can never steer an NMT engine. You can also, without intending to, instruct it right out of faithful translation and into creative writing, as Elin's warranty bake-off showed.

Second, the LLM has a context window. The context window is the span of text the model can hold in view at once, the working memory of the conversation, often thousands or tens of thousands of tokens. Where the NMT engine sees one isolated segment and forgets it, the LLM can see the whole paragraph, the surrounding document, the glossary you pasted, the previous sentences it just produced. This is a genuine advantage. An LLM can resolve a pronoun by looking back, keep a term consistent across a passage, pick up that the document is a legal contract and adjust register, handle an idiom by understanding the sentence it sits in rather than mapping it word for word. For context, register, and fluency, the LLM is frequently the better translator. It sounds more human because it has read more human writing than any NMT engine ever trained on narrow parallel text.

An NMT engine is a translation specialist with no memory and no instructions. An LLM is a general writer with memory and instructions who can be asked to translate. The first is anchored to the segment; the second is anchored to plausibility.

The Failure Signature of the LLM

Now the cost of that nature. Because the LLM is optimizing for plausible, fluent continuation rather than faithful transfer, and because it is following your instructions and its own sense of what good writing looks like, its errors have a different and more dangerous signature than NMT's:

• Confident invention (added content). The LLM fills gaps it perceives. Elin's refund window came from nowhere in the source; the model decided a warranty notice "should" mention a timeline and supplied one. NMT rarely adds whole facts that are not anchored to the input. An LLM will, smoothly, and present them with the same authority as the parts it got right.
• Instruction-following drift. Asked to "make it natural" or "punch it up," the LLM may quietly prioritize the styling instruction over fidelity to the source, softening a warning, dropping a negative framing it finds unfriendly, or reshaping the meaning to fit the tone you requested. The instruction you gave to improve the prose became permission to leave the source behind.
• Register and intent slips. An LLM that decides the content is marketing may warm up a sentence the source meant to be a stern legal warning, or formalize a casual line. It is matching a register it inferred, which may be the wrong register for content whose tone is load-bearing.
• Confidently wrong on facts. When the LLM is wrong, it is wrong with total composure. There is no tonal tell, no hedge, no flicker of uncertainty between its correct outputs and its fabricated ones. The fluent lie and the fluent truth are dressed identically.

The deep difference, the one to carry out of this lesson, is about where each engine fails relative to the source. NMT fails at the source: it mishandles something that is genuinely in the segment, so you can find the error by comparing output to input. The LLM can fail away from the source: it can produce fluent target text that has only a loose relationship, or no relationship, to what the source actually said, because its loyalty is to plausible prose and your instructions, not to the segment. You cannot always catch that by checking whether the output reads well, because it always reads well. You can only catch it by holding the output against the source meaning and asking the harder question: is this what the source actually said, or is it what a good writer would have written instead?

Why Fluency Is Exactly What Hides the Error

This is the heart of it, and it is worth slowing down. Your whole career has trained one reflex into you: smooth, grammatical, confident prose is a sign of competence. A sentence that reads beautifully has, in the human world you learned the craft in, almost always been written by someone who knew what they were doing. That reflex is a survival skill when you are reviewing human work. It is a trap when you are reviewing machine work, and it is the worst trap with an LLM, because the LLM is the most fluent machine.

Run the logic forward. The LLM's defining strength is fluency: it produces the most natural-sounding target text of any engine you will use. Its defining failure mode is confident invention: it produces fluent text that departs from the source. Those two facts are not separate. They are the same fact seen from two sides. The very generative freedom that lets the LLM write a sentence more beautifully than a narrow NMT engine is the freedom that lets it write a sentence that is more beautifully wrong. The fluency is not a layer on top of the error you can peel back to inspect. The fluency is the camouflage. The smoother the prose, the more your trained eye relaxes, and the more your trained eye relaxes, the further past the error you skim.

Compare the two crimes one more time through this lens. The NMT engine's stiff "the proof of purchase" actually trips your eye a little; the slight awkwardness is a flag that something was transferred mechanically, and an alert post-editor pauses there. The LLM's invented refund window does the opposite: it reads so well that your eye glides over it with approval. The better the writing, the less you scrutinize it, and the LLM writes the best. An engine that produced clumsy errors would be safer, because clumsiness is self-announcing. The LLM produces elegant errors, and elegance is silence.

The LLM's fluency and the LLM's danger are the same property. The freedom to write a sentence more beautifully is the freedom to write a sentence that is more beautifully wrong, and beauty is what your eye is trained to trust.

The Confidence Without a Tell

There is a second, related cruelty. A human expert who is unsure signals it. They hedge, they footnote, they flag the ambiguous passage for the PM, they write "literally X, but consider Y" in a comment. Neither engine does this, but the LLM's lack of a tell is more dangerous precisely because it is so articulate. When an LLM invents the refund window, it does not write it in a hesitant voice. It writes it in the same confident, polished register as the parts it translated faithfully. There is no visual or tonal difference between the segment it nailed and the segment it fabricated. You are reading a witness who is equally fluent when telling the truth and when lying, and who shows no sign of which is which. The only instrument that distinguishes them is the source, held up against the output, claim by claim.

Side by Side: Where Each Engine Fits

None of this is an argument that one engine is good and the other bad. It is an argument for knowing which machine you are standing on and reading its output for its specific failure signature. Used with their natures understood, each earns its place in a pipeline.

Reach for Classic NMT When

Neural MT is the workhorse for high-volume, repetitive, sentence-bounded content where the source is clean and segment-by-segment fidelity is what you need: product catalogs, support articles, internal documentation, the bulk of a software product's interface strings, user-generated content at scale. The engine is fast, cheap, and its failure modes are known and checkable. Because it stays anchored to the source, you verify it by comparing output to input clause by clause, and a disciplined post-editing pass with a verification step turns its speed into safety. You read NMT output asking: did it drop a negation, corrupt a number, lose a clause, swap an approved term? Those are bounded questions with findable answers.

Reach for an LLM When

An LLM earns its keep where context, register, and fluency matter more than narrow sentence fidelity, and where a human will own the output anyway: drafting, adapting tone, handling longer context a segment-bound engine fragments, resolving a pronoun or an idiom that needs the surrounding paragraph, suggesting terminology candidates for a human to approve, first-pass transcreation a human then shapes. Its context window and prompt-following are real advantages here. But you read LLM output asking a different and harder set of questions: did it add anything the source did not contain? Did it follow my styling instruction so eagerly that it left the meaning behind? Did it shift the register of content whose tone was load-bearing? Did it state a fact, a number, a promise, that exists nowhere in the source? Those questions cannot be answered by checking whether the prose reads well. They can only be answered against the source.

The Blurred Middle and the Discipline It Demands

The line between the two is blurring in 2026. Some production engines now blend approaches, giving an NMT-style backbone more context awareness, or wrapping an LLM in guardrails that pin it harder to the source. That is genuine progress, and it does not change your job. Whatever the engine, the discipline is the same: identify which failure signature the output is prone to, and read against it. If the engine is anchored to the source and fails by drift and omission, hunt for the dropped negation and the corrupted number. If the engine is free and fails by invention and instruction-drift, hunt for the added content and the register slip. The most dangerous posture is to treat a fluent LLM rendering with the same checklist you would use on a stiff NMT one, because the LLM's errors live in a place the NMT checklist never looks: in the gap between a beautiful sentence and a faithful one.

Match the engine to the job and read the output for its signature. NMT errors hide at the source and are findable by comparison. LLM errors hide away from the source, behind fluency, and are findable only by asking whether the beautiful sentence is actually true to the original.

What This Means for Your Monday

Elin's bake-off ended the way these always should: not with a winner, but with a routing decision. She put the neural MT engine on the high-volume warranty and support content, where its anchored, checkable errors fit a fast post-editing pass, and reserved the LLM for the marketing landing pages, where its fluency and context-awareness were assets and a human copywriter was going to own the final word anyway. Crucially, she wrote into the pipeline a rule that the LLM's output on any content with a factual claim, a number, a warning, or an obligation would be checked against the source for invented or altered content, every time, because she now understood that the LLM's elegance was not a reason to trust it. It was the reason to distrust it most.

That is the whole lesson made operational. The difference between neural MT and LLM translation is not that one is newer or one is better. It is that they are built differently, anchored differently, and break differently, and the break that should frighten you more is the LLM's, precisely because it arrives wrapped in the best prose. When every segment in your file is pre-populated and the deadline assumes the machine did the thinking, the question is never "does this read well." The machine guarantees that it reads well. The question is always "is this what the source said," and only you, holding the output against the source, can answer it. The engine handed you speed. Knowing which engine you are reading, and what it is prone to lie about, is how you keep that speed from handing you a Critical error with your name on the delivery.

Key Takeaways

• Machine translation (MT) is the umbrella term; neural machine translation (NMT) is a narrow neural network trained only to translate, built on parallel corpora of source-and-target sentence pairs using an encoder-decoder architecture that compresses the source's meaning and then decodes a target sentence one piece at a time.
• Classic NMT is segment-bound: it translates one sentence in isolation, with no context window and no memory of the segments around it. That narrowness makes it fast, cheap, and predictable, and also blind to anything outside the current segment.
• A large language model (LLM) is a general text-prediction system trained on a broad corpus to predict the next token; it was not built to translate but does so as a side effect. It is prompt-driven and has a context window, so it is more fluent and more context-aware than segment-bound NMT.
• The engines fail in different places relative to the source. NMT fails at the source by drift, omission, terminology drift, and hallucination on thin input, so its errors are anchored to the segment and findable by comparing output to input clause by clause.
• An LLM can fail away from the source: confident invention and added content, instruction-following drift when a styling prompt overrides fidelity, register and intent slips, and facts stated with total composure that exist nowhere in the original.
• The LLM's fluency and its danger are the same property. The generative freedom that writes a more beautiful sentence is the freedom that writes a more beautifully wrong one, and a trained reviewer's eye relaxes on smooth prose, skimming past the elegant error.
• Neither engine signals uncertainty, but the LLM's lack of a tell is worse because it states fabrications in the same confident, polished register as its faithful output. The only instrument that separates the fluent truth from the fluent lie is the source held against the output.
• Match the engine to the job and read for its signature: NMT for high-volume, sentence-bounded, checkable content; LLMs where context, register, and fluency matter and a human owns the output. Never read a fluent LLM rendering with the NMT checklist, because the LLM's errors live in the gap between a beautiful sentence and a faithful one.