What It Protects

Pasting subtitles into a chatbot goes wrong in predictable ways. This page lists those ways, and what Polygluttony does about each one.

Lines go missing, merge or swap places

The problem: send a model 100 numbered lines and it may give back 99, two lines run together, or the order shuffled. Every line after that sits at the wrong timestamp.

What Polygluttony does:

• Every line goes out with a numbered marker, like <0042:D>, and has to come back with it.
• When a reply comes back, the markers are checked: missing, extra, duplicated, mangled, out of order.
• Everything before the first bad line is kept. Only the rest is sent again.
• If most of a batch came back broken, the batch size is halved and tried again. Once it's down to 10 lines and still failing, it stops, and those lines are left out instead of being guessed at. They're flagged UNTRANSLATED, and the run's summary counts them ("60 lines weren't translated").

The translation wanders from the source

The problem: partway through a long batch, a model can start paraphrasing, skipping ahead, or translating the wrong lines, and it all still reads fine.

What Polygluttony does: after each episode it compares source and translation, line by line, on five signals:

1. Punctuation: a question should stay a question, an exclamation an exclamation.
2. Glossary: each glossary term in the source should have its agreed translation in the line.
3. Sentence type: statements and questions shouldn't swap, and quoted speech should stay quoted.
4. The last line: gets a stricter check of its own, for missing glossary terms, an odd length, or nothing at all.
5. Length: a translation that's far shorter or longer than its source is suspicious.

Then the Verify model reads a sample of lines from the beginning, middle and end, looking for translations that have nothing to do with their source. Flagged parts are translated again, up to twice. Lines still in doubt are flagged MEANING ("This line may not say what the original says."), with Verify's reason when it gave one.

Names change between episodes

The problem: without a list to follow, a model translates 九婴 one way in episode 3 and another way in episode 9.

What Polygluttony does: the glossary. Each batch carries the agreed translation of every term that appears in it. When an episode is done, every line is checked against the glossary: a line whose source has a term but whose translation doesn't use the agreed name is flagged NAME, with the term and what it should be ("…" should be "…" here, per your glossary). Name issues don't trigger a retranslation by themselves; you decide in the episode window.

The typesetting breaks

The problem: models "helpfully" translate, drop or move {\an8}, {\pos(…)} and {\fad(…)} tags, and the result renders wrong.

What Polygluttony does: the model never sees the tags. They're taken out before sending and put back afterwards. Styles, timings and script info are copied straight from your file. See Folders & files.

Source text leaks into the translation

The problem: a few lines come back half-translated, with Chinese still in them.

What Polygluttony does: any line where more than 10% of the characters are still in the source script is sent again on its own, up to three times. It only keeps a reply that comes back clean. This is meant for a handful of stray lines. If more than 10 lines in an episode are affected, the clean-up is skipped and noted in Logs.

The provider hiccups

The problem: timeouts, "too many requests", servers having a bad minute.

What Polygluttony does: each request gets up to three attempts, following the provider's "retry after" hint when it gives one. When a provider says it's getting too many requests, Polygluttony halves the number it sends at once and builds back up gradually; the episode shows "Waiting — Anthropic asked us to slow down · 18s" in the meantime.

A rejected API key, an account out of credit, or a model the provider doesn't know stops the whole run straight away, instead of failing every remaining batch. The banner says why in one sentence ("Anthropic rejected the API key used for Translate.") and offers Open Models and Try again. Episodes that finished are kept.

Where you see it

Every episode on the Episodes page gets a status: Done, Needs a look (with a count, like "Needs a look · 20 lines missing, 8 more"), Failed or Not finished. Fold out a Needs a look row to see its issues, or press Review to open the episode window and step through the flagged lines, fixing each one or marking it Looks fine. See Reading the results.

What it doesn't do

So you know where your own eyes are still needed:

• The AI check reads a sample of lines, and it's deliberately lenient. It catches translations that are clearly off, not ones that are merely clumsy.
• Tags in the middle of a line go back at the same relative position, which may not be next to the same word.
• Embedded fonts ([Fonts]) and Comment: lines aren't carried over.
• A translation you change in another editor isn't checked again. The issues Polygluttony found stay with the episode (they're stored, so they survive a restart), and Review won't write over a file that was changed outside Polygluttony.