Multi-Model LLM Collaboration for Interview Translation: A Practical Workflow

    This article lays out a practical, engineering-oriented workflow for translating long-form interviews — using anime/music project interviews as the running example — with multiple large language models collaborating. It explains why interviews resist direct machine translation, then walks through a five-stage pipeline: source collection, preprocessing with glossary injection, parallel multi-model translation, candidate selection and merging, and human review/QA. It shows how to build a custom glossary for terminology consistency, design prompts that turn "translate the meaning, not the words" into checkable rules, score and select candidates automatically, allocate human review by risk, and measure quality through evaluation and regression. It closes with engineering, cloud-deployment, and compliance guidance. Readers will learn to divide roles across a base model and reference models, keep terminology consistent, and combine AI speed with human accuracy.

    Introduction: The Engineering Behind an AI Translation Note

    An AI-assisted translation note for an anime music interview listed the translation tools, the several LLMs used, and the role each one played. It noted that the final translation for most of the “not-quite-literal” text was taken from one particular model, and that this text ended up accounting for “more than half” of the finished piece — effectively a second base draft. The team also injected a custom glossary and ran “a round of manual proofreading.”

    The note is dense with information. It shows that the production team treated translation as an engineering process rather than a one-click task. The core ideas boil down to four points:

    • Multi-model division of labor: assign each model a role — base draft, reference, or high priority.
    • Terminology first: build and inject a custom glossary up front.
    • Human gatekeeping: key text goes through manual proofreading.
    • Justified choices: record why each piece of text was ultimately adopted.

    This article follows the same approach, abstracts these elements into a general methodology, and uses an anime music interview as a worked example to present a reusable workflow design.

    1. Why Interviews Resist “Direct Translation”

    Interviews are conversational: short, fast-paced, and often delivered aloud with improvised phrasing, which makes them non-trivial to understand. Interviews for anime music projects have a few distinctive traits:

    1. Dense proper nouns. Song titles, event names, character names, unit names, and project-specific coinages appear frequently, most of them in katakana or invented terms.
    2. Large contextual jumps. Topics often shift back and forth within a single paragraph, pronouns are ambiguous, and you have to look back at the preceding text to pin down the subject.
    3. Mixed registers. Written prose, casual speech, the interviewer’s questions, and the interviewee’s own words alternate.
    4. Interleaved text and images. Interview pages often include song preview blurbs, cover-art captions, copyright pages, and ad pages.

    Some Japanese conventions — omitted subjects, indirect negation, honorific levels, sentence-final tone — have no direct equivalent in Chinese, and these are exactly where mechanical literal translation tends to break down.

    By task type, machine translation (MT) and generative LLM translation each have their strengths:

    Dimension Machine Translation LLM Translation
    Main strengths High throughput, low latency, relatively controllable cost; good for standardized short text Understands meaning from context; can follow a glossary and style requirements
    Main weaknesses Limited support for context and terminology constraints Higher inference latency and token cost; may rewrite the source or improvise
    Suitable for UI strings, feature descriptions, and other formatted content Interviews, editorials, spoken scripts, and other context-heavy content

    Interviews fall squarely in the LLM’s strong zone, so LLM translation backed by human review is a reasonable choice. But the overall quality of an interview doesn’t depend on any single model; it depends on how well the pipeline — input organization, model division of labor, result selection, and human review — is designed.

    2. Overall Architecture: Primary/Backup Division and a Quality Loop

    The workflow breaks into five stages:

    1. Source collection → Preprocessing & glossary injection → Parallel multi-model translation → Candidate selection & merging → Human review & QA

    Key points for each stage:

    • Preprocessing: run OCR first for screenshot-style interviews, then clean up layout residue.
    • Glossary injection: load the glossary before calling the models.
    • Parallel multi-model translation: dispatch each paragraph to both a “base model” and a “reference model” at the same time.
    • Result selection and merging: the base draft is the default adoption; the reference model is used to surface possible improvements.
    • Human review and QA: the reviewer adjudicates between the two versions and handles problems that can’t be decided automatically.

    Choosing the base model matters more than “picking the single strongest model.” The base determines the vast majority of paragraphs, while the reference model is responsible for flagging “this paragraph might have a problem.”

    The model chosen as the second base draft in the translation note above actually accounted for more than half of the output and was likely selected as the default after reading and comparing candidates. This shows that a base model should be evaluated on terminology and tone/style, sentence structure, honorific handling, and restraint — not rewriting on its own initiative, and not adding or removing information.

    Even when the reference model is given higher priority, treat its output as a “second opinion” first. Adopt it only for paragraphs where it offers a clear reason for improvement; otherwise fall back to the base to avoid introducing another style.

    One more caveat: the base and reference should ideally come from different model families or technical approaches. If they share the same origin and differ only in prompt or reasoning effort, they tend to make the same mistakes, and cross-checking adds little value.

    3. Custom Glossary: Consistency Infrastructure

    3.1 Fix the Standard, Then the Term

    The first principle of a glossary is that a translation must be unique: one Japanese word maps to exactly one Chinese translation, though the reverse doesn’t need to be one-to-one.

    The following cases usually shouldn’t be translated: terms with a translation already fixed by official Chinese materials, invented terms in the work’s setting, and names commonly shared between official sources and the fan community.

    Record the standard in the header. For example:

    Source (Japanese) Translation (Chinese) Part of speech Rule Notes
    ライブ 演出 noun Unified throughout Don’t mix in variants like “on-site” or “Live”
    センター 中心位 noun Only when referring to a stage position Translate normally when it means “center” in general
    (original title) (official unified translation) proper noun Keep the unified spelling Add a translator’s note when no official name exists

    3.2 Making the Glossary Actually Take Effect

    The interfaces below are illustrative and don’t represent any specific service.

    1. import re
    2. def build_glossary(path: str) -> dict:
    3. """Load the glossary and return {source: entry}. Deduplicate first and check that translations don't conflict."""
    4. ...
    5. def match_terms(text: str, glossary: dict) -> list[dict]:
    6. """Scan the source for glossary entries that match, longest terms first."""
    7. hits = []
    8. for src in sorted(glossary, key=len, reverse=True):
    9. for m in re.finditer(re.escape(src), text):
    10. hits.append({**glossary[src], "offset": m.start()})
    11. return hits
    12. def build_messages(text: str, glossary: dict, prompt_tpl: str) -> list[dict]:
    13. terms = match_terms(text, glossary)
    14. # Inject only the terms matched in the current paragraph to keep context length in check
    15. glossary_block = "\n".join(
    16. f"- {t['source']}: {t['translation']}"
    17. + (f" ({t['note']})" if t.get("note") else "")
    18. for t in terms
    19. )
    20. return [
    21. {"role": "system", "content": prompt_tpl},
    22. {"role": "user", "content": f"[Terminology requirements]\n{glossary_block}\n\n[Source text]\n{text}"},
    23. ]

    In practice, consider these approaches:

    • Nearby injection: inject only the terms matched in the current paragraph to control context length. This is the common way “inserting a custom glossary during translation” is implemented.
    • Longest-first matching: match longer terms first so short words don’t claim a hit prematurely and cause terms to be split incorrectly.
    • Conflict detection: during maintenance, list cases where “one word has multiple candidate translations” and deprecate the non-preferred ones.
    • Operations coordination: stay in touch with the glossary provider — for example, watch for new songs or event announcements from the operations side and add them promptly.

    3.3 Check Programmatically Whether Terms Were Applied

    Model instructions can’t guarantee 100% compliance, so add a programmatic check:

    1. def glossary_report(src: str, dst: str, glossary: dict) -> dict:
    2. hits = match_terms(src, glossary)
    3. missing = [t["translation"] for t in hits if t["translation"] not in dst]
    4. return {"term_count": len(hits), "missing_translations": sorted(set(missing))}

    This check only catches cases where “the translation doesn’t appear,” not cases where “a wrong synonym was used.” Treat it as a proofreading hint, not an automatic scoring criterion.

    4. Prompt Design: Turning “Don’t Translate Literally” into Explainable Rules

    “Don’t translate literally” isn’t a slogan; it should be broken into a set of executable, checkable constraints:

    • Meaning first: don’t map word for word; convey the full original meaning.
    • No additions or deletions: don’t add information absent from the source, and don’t omit information present in it.
    • Punctuation: follow Chinese publishing conventions for punctuation.
    • Register consistency: don’t casually turn speech into writing, or vice versa.
    • Information retention: keep the source where necessary, such as song titles on first appearance and Japanese onomatopoeia.
    • Uncertainty markers: output a to-be-confirmed marker where you can’t decide, rather than fabricating.

    A sample structure:

    1. [Role] You are a translator producing interview translations for Chinese readers.
    2. [Input] A source paragraph + the glossary entries matched in the current paragraph + context snippets.
    3. [Requirements] Keep the meaning complete; add or remove nothing; preserve each speaker's tone; use consistent punctuation; mark uncertain spots with [?].
    4. [Output] Output only the translation, no explanations.

    To reduce the risk introduced by multiple rounds of rewriting, use a two-pass “draft-then-polish” strategy:

    • Pass 1: literal-leaning, aiming only for complete information — this corresponds to the “base draft” or the “not-quite-literal text.”
    • Pass 2: polish the draft toward the target style — this corresponds to the text that “actually becomes the finished piece.”

    This way every change is traceable. When a translation is disputed, you can tell whether the problem lies in the understanding stage or the expression stage.

    When two models handle the same paragraph, the differences cluster into five categories:

    1. Terminology choice;
    2. Sentence splitting (Chinese favors short sentences);
    3. Filling in omitted elements (who did what);
    4. Honorifics and tone;
    5. Handling of numbers, proper nouns, and loanwords.

    Once the reviewer decides which category applies, deciding what to keep becomes noticeably faster.

    5. Result Selection: More Models Isn’t Always Better

    5.1 Anomalies You Can Detect Automatically

    • Abnormal length: an over-long translation often means restatement or over-translation; an over-short one often means omission.
    • Missing numbers or proper nouns: numbers or IDs in the source don’t appear in the translation.
    • Output contamination: chat-style openers like “Sure” or “Here is” mixed in, or explanatory text appended at the end.
    • Added or removed information: speakers or evaluations not in the source get added; conditions in the source get dropped.
    • Uncertainty markers: a model’s [?] output needs human review.

    Start with two scores:

    • Base score: defaults to 1.0, with points deducted per anomaly above.
    • Terminology score: points deducted for missing translations.
    1. NUM_RE = re.compile(r"\d+")
    2. def score_candidate(dst: str, src: str, glossary: dict) -> float:
    3. s = 1.0
    4. if len(dst) < 0.5 * len(src) or len(dst) > 2.0 * len(src):
    5. s -= 0.2
    6. if set(NUM_RE.findall(src)) - set(NUM_RE.findall(dst)):
    7. s -= 0.3
    8. s -= 0.2 * len(glossary_report(src, dst, glossary)["missing_translations"])
    9. if "[?]" in dst:
    10. s -= 0.1
    11. return max(s, 0.0)

    Composite score = human relevance weight × base score + (1 − human relevance weight) × terminology score.

    The “human relevance weight” is set by the team according to content importance. The numbers above are illustrative and need calibration through human sampling.

    5.2 From “Whole-Piece Pick-One” to “Paragraph-by-Paragraph Adjudication”

    There are roughly three strategies for handling multi-model output:

    1. Single model, direct output: lowest cost and latency, but no verification.
    2. Single model plus QA: one model produces, another reviews and edits — clear pipeline, medium cost.
    3. Multi-model cross-checking plus human adjudication: highest consistency, suited to long interviews with strict style and terminology requirements.

    The approach above is the third: first fix the base and reference, then have a human decide per paragraph whether to adopt the reference version.

    Consider showing the base and reference side by side in the UI, with the reference model’s rationale collapsed — as a basis for judgment, not a final verdict.

    If the proportion of cases where the reference is “better” stays low over time, the base choice or the prompt needs adjusting; if it stays high, consider changing the default version.

    6. Human Review: Set Priorities Rather Than Spreading Effort Evenly

    The key to “a round of manual proofreading” is to put limited effort where errors are most likely. Assign review intensity by paragraph type:

    Paragraph type Recommended approach
    High-quality, likely direct-output paragraphs Quick read-through; check terminology and numbers
    Paragraphs where reference and base diverge Careful comparison; decide which to adopt
    Difficult spots (puns, memes, euphemisms) Confirm sentence by sentence; add a translator’s note if needed
    Titles, lead-ins, copyright, and track listings Check word by word

    After the whole translation is done, add a round of “consolidated view” review:

    • Extract all lines by speaker and check whether each character’s tone stays consistent throughout.
    • Aggregate every occurrence by term and check that translations are unified.
    • Aggregate by number and time and check that they match the source.

    This lets you catch consistency problems across the whole piece without re-reading paragraph by paragraph.

    7. Evaluation and Regression: Making Quality Measurable

    Score the evaluation table on these dimensions:

    • Accuracy: is the meaning complete; any mistranslations, omissions, or additions?
    • Terminology consistency: are translations unified?
    • Language naturalness: does it read like Chinese speech or writing?
    • Format compliance: speakers, punctuation, numbers, and translator’s notes per requirements.

    After each change to the prompt, glossary, or model roles, re-run a fixed sample set (built from historical and difficult paragraphs) and compare score changes to avoid “fixing one thing and breaking many.”

    8. Engineering and Compliance Considerations

    8.1 Engineering Essentials

    • Segmentation and context: when paragraphs reference earlier text, bring 1–2 preceding paragraphs rather than re-translating the whole piece.
    • Concurrency and rate limiting: set concurrency per each service’s actual quota, with retries and backoff, to avoid batch-task failures.
    • Caching and incremental work: use a hash of the source text as the cache key; reuse old results when the source is unchanged to cut wasted calls.
    • Layout handling: group non-interview content like ads, copyright, and preview notes separately, and process as needed.
    • File management: keep source, glossary, multi-model outputs, and the final draft together in managed file storage with version control.

    8.2 A Cloud Deployment Approach

    Translation services typically involve LLM inference, cache storage, file management, logging, and monitoring, all of which can be deployed on Baidu AI Cloud:

    • Use models such as ERNIE on the Qianfan model platform as the base or reference model.
    • Store source and translated drafts in object storage, and use function compute to run batch-task orchestration.
    • Use logging services and monitoring alerts to track call volume, failure rate, and response latency.

    For the specific parameters and pricing of each product, refer to the official documentation.

    8.3 Compliance Red Lines

    • Authorization first: translating and publishing someone else’s work without authorization may infringe the translation right, so obtain authorization first, or at least limit use to personal study and research.
    • Privacy: for content involving minors, avoid sending personal information to external models.
    • Clear labeling: prominently mark the translation as “AI translation + human proofreading,” include the source and version date, and state that it is “not an official translation.”
    • Restrained polishing: polishing must not change the original meaning; additions should be marked in a translator’s note.

    Conclusion

    The most valuable takeaway from the translation note above isn’t which model was used, but the clear division of roles: the base carries the default output, the reference provides a point of comparison, the glossary ensures consistency, and human review holds the line.

    Distill these four points into a configurable, measurable pipeline, and you can reliably produce high-quality Chinese translations for any anime project interview — from a single release to an anniversary feature. AI translation handles “speed,” the glossary handles “stability,” and human review handles “accuracy” — none can be missing.