You built the glossary. You attached it to the job. The model translated your key term three different ways in the same document anyway.

Attaching a glossary and enforcing one are different problems, and most pipelines only solve the first. The good news is that the second is unusually cheap: a single explicit instruction in the prompt is worth about 12 percentage points of terminology accuracy (arXiv:2605.14679). Almost nothing else in translation engineering pays that well for that little.

This guide covers what to put in the prompt, why the obvious version underperforms, and how to verify the terms that actually matter.

Why a glossary alone does not hold

An LLM is a fluency engine. Left to itself, it will vary its wording — that is what makes its output readable, and it is exactly what you do not want in a contract, a datasheet, or a registry extract.

Three failure modes recur:

Synonym drift. The term is rendered correctly the first time, then paraphrased later in the document. A reader sees two words and reasonably assumes two things.

Morphological escape. The model uses your term but reshapes it to fit the sentence. In languages with rich inflection this is often correct and desirable — and sometimes it silently changes a legal designation into something that means nothing.

Polite substitution. The model decides your term is awkward and quietly improves it. This is the worst one, because the result reads better than the correct answer.

None of these are comprehension failures. The model understood. It simply was not told that consistency outranks fluency here.

The instruction that earns the 12 points

The version most pipelines ship looks like this:

Glossary: "интеллектуальная собственность" = "intellectual property"

That is a hint. The model treats it as a suggestion, because nothing in it says otherwise.

The version that measures better says three things explicitly — use it exactly, use it every time, and prefer it over a smoother alternative:

Terminology (MUST be followed):
- "интеллектуальная собственность" → "intellectual property"
- "исключительное право" → "exclusive right"

Rules:
- Use the target term exactly as given, every time it appears.
- Keep it consistent across the whole document — do not vary the wording
  for style.
- If the term does not fit grammatically, adapt the surrounding sentence
  rather than the term.

That last line is the one people leave out, and it is doing real work. Without it the model faces a conflict — your term versus a grammatical sentence — and resolves it by bending the term. Telling it which side may bend removes the ambiguity entirely.

Give hints per segment, not per document

There is a second, structural improvement that costs nothing: attach the glossary entries that are relevant to this segment, rather than pasting the whole glossary into every call.

A 400-term glossary in every prompt is expensive, and worse, it is noisy — the model has to find the two entries that matter among 398 that do not. Matching terms against the segment first and sending only the hits gives you a short, pointed list:

Glossary (MUST use these translations): 'ОГРН' → 'OGRN', 'ЮЛ' → 'legal entity'

Our own pipeline does this per segment and per batch, and the difference is not subtle: a segment prompt that names two terms gets both right far more reliably than one that buries them in a wall of terminology.

Batch translation needs the mapping to survive batching

If you translate segments in batches — and you should, for cost — the per-segment hints have to stay attached to their segment. It is easy to write a batch prompt that collects every hint into one list at the top, and it is easy for the model to then apply a term from segment 3 to segment 7.

Number them alongside the segments:

Translate each numbered segment:
[0] Сведения об основном виде деятельности
[1] ОГРН 1132537002553

Per-segment glossary (MUST use these translations):
  [1]: 'ОГРН' → 'OGRN'

The indices tie each hint to its segment. Without them a glossary is a bag of words, and a model that reaches into that bag at the wrong moment produces terminology errors that look like hallucinations.

Verify the terms that matter with back-translation

Prompting raises the hit rate; it does not guarantee it. For the handful of terms where an error is expensive — legal designations, product names, regulatory categories — add a verification pass.

Back-translation is the cheap version. Take the translated segment, translate it back to the source language, and check whether the critical term survives the round trip:

Source: исключительное право
Target: exclusive right
Back-translated: исключительное право ✓

When step 3 comes back as something else, you have a signal worth a human's attention. This is a screen, not a proof — back-translation has known blind spots, and a wrong term can round-trip cleanly if the error is symmetric. But it catches substitution and drift, which are the two failure modes that matter most, and it costs one extra call on a short list of terms rather than on the whole document.

Reserve it for terms you have marked critical. Running it over an entire document doubles your cost to check things nobody will dispute.

Glossary versus translation memory

These solve different problems and it is worth being precise, because pipelines that confuse them get both wrong.

A glossary is term-level and prescriptive: this word must be rendered this way. It applies inside a segment, wherever the term appears.

A translation memory is segment-level and historical: this whole sentence was translated this way before, so reuse it. It applies when a segment matches something already approved.

TM reuse is exact or fuzzy at the sentence level. Glossary enforcement operates below that, on the words inside a sentence that TM did not match. A document can be 80% TM reuse and still need glossary enforcement on the remaining 20%, and a fresh document with no TM at all still needs its terminology held steady.

If you want the term to be reused across sentences, that is a glossary. If you want the sentence reused, that is TM.

Key takeaways

An attached glossary is a hint; an enforced glossary is an instruction. Say "MUST", say "every time", and say what to do when the term does not fit grammatically.
The line people omit is the one that resolves the conflict. Tell the model to adapt the sentence around the term rather than adapting the term.
Send the terms that match this segment, not the whole glossary. A short pointed list beats a long noisy one, and it costs less.
Keep hints tied to their segment in a batch. Number them, or a term from one segment will surface in another.
Back-translate only the critical terms. It is a screen for substitution and drift, and running it on everything doubles the bill for no gain.

FAQ

How large can a glossary be before prompting stops working?

The limit is not the glossary size, it is how many terms you put in one prompt. Match against the segment first and send only the hits — a 400-term glossary works fine when any given call sees three of them.

What if two glossary terms overlap?

Prefer the longer match. "exclusive right" should win over "right" when both appear. Resolve overlaps before building the prompt rather than hoping the model resolves them, because it will resolve them differently in different segments.

Does this work with terms that must be inflected?

Yes, and this is where the third rule matters most. Instruct the model to adapt the surrounding sentence rather than the term. For languages where the term genuinely must decline, mark those entries as inflectable and say so explicitly, rather than leaving the model to guess whether "exactly" means "never changed."

Should I enforce a glossary on machine translation output or during translation?

During. Post-translation replacement is a blunt instrument: it hits substrings inside other words, breaks agreement with the surrounding sentence, and cannot tell a real occurrence from a coincidence. Enforcement during translation lets the model build a correct sentence around the term.

Is 12 percentage points worth the extra prompt tokens?

Yes, by a wide margin. The instruction is a few dozen tokens per call, and matched hints are shorter than a full glossary would be. Compared with re-translating a document that failed terminology review, it is not close.

Conclusion

Terminology control is one of the few places in translation engineering where a small, specific change produces a large, measurable improvement. The instruction takes a few lines. The per-segment matching is straightforward. The back-translation check applies to a short list, not the whole document.

What you get is the difference between a glossary that exists and a glossary that holds — which, for anyone whose documents get read line by line against a source, is the whole point of having one.

KTTC applies glossaries per segment during translation and holds terminology across template-based documents where a varied term is a rejected filing. Try KTTC with your own glossary and see how much of it survives.