Synthetic multilingual data: six release gates

A synthetic multilingual data pipeline deserves scale when it retains the source document, separates generation from acceptance, measures quality by language and script, controls duplicates across splits, and demonstrates improvement under a fixed training budget. On October 16, 2026, NVIDIA and AI4Bharat described Nemotron-pretraining-Indic-v1: roughly 2.8 trillion generated tokens for 22 Indian languages and 34 language-script configurations, together with an open recipe for translation, assessment, and repair. The news was three Lima calendar days old when consulted on October 19. The broader corpus was announced as an upcoming release, so the verifiable advance today is the documented mechanism and technical report, not immediate availability of all data. It also does not prove that translating more text improves every product: the work itself combines synthetic and natural data, and its results belong to that mixture and one particular model.

The CTO decision is not whether the team can produce more tokens. It is whether the team can defend why a sample entered the corpus, which known error it retains, who can stop the batch, and which comparison would show that training justified the cost. A translated file is a candidate; only an acceptance policy turns it into training data. That separation prevents the generator from quietly owning quality as well and lets teams rerun filters without regenerating all material.

The published recipe starts with curated English documents and retains an identifier alongside every derivative. For twelve languages, it translates the complete document, assesses the output against the source with a rubric, repairs low-scoring outputs, and assesses them again. Only then does it create a romanized version of part of the accepted translations. For another ten languages, it adapts the flow: a different translation model, overlapping windows for long Santali documents, and a specific script conversion for Manipuri. The mechanism matters because it treats language, script, and length as operating properties rather than one generic locale label.

Generation, assessment, and repair produce different artifacts. Teams should retain the immutable source, candidate, dimension-level score, detected errors, repaired version, and final decision. Prompt, model, tokenizer, and configuration versions must also be pinned. Without that lineage, a new threshold cannot reconstruct the corpus, and an apparent improvement may come from another mixture, another token-counting method, or an unrecorded manual correction.

The same source can produce versions in several languages and scripts. Splitting train, validation, and test after translation therefore creates leakage: semantically equivalent derivatives can land on both sides. The split unit must be the provenance group, before variants are generated. Token count is also not the same as unique documents or the budget the model will ultimately see; the announcement distinguishes those three quantities, and any internal dashboard should preserve that distinction.

Gates should evaluate persisted evidence, not team confidence or a global average. Each needs a rejection condition, an owner, and an auditable artifact. If a language lacks a competent evaluator, a source license is uncertain, or splits share the same origin, the batch stops even when total volume looks impressive.

A threshold is policy, not nature. The reference pipeline uses an MQM-inspired rubric and, for its twelve-language flow, retains translations scoring at least 75 out of 100. That number is a rubric score, not 75% accuracy, and it should not be copied into another domain without human calibration. Legal contracts, medical content, and informal support require different error distributions and tolerances. The right gate defines which severities are unacceptable for the intended use and measures agreement among judges before automating the filter.

Hypothetical example: a B2B platform wants to improve a support assistant for Peruvian Spanish and a second language variety in its market. Instead of translating the entire knowledge base, it selects one narrow domain—account recovery, for example—with current documents and clear rights. Before generation, it creates a held-out set with anonymized real questions, reference answers, and safety criteria. Source-document groups are assigned to train or evaluation before variants are produced; no sibling translation may cross that boundary.

The pilot runs translation, assessment, and repair as separate jobs. Competent reviewers inspect samples stratified by intent, length, and script; they also receive deliberately damaged cases to verify that the judge catches omissions, changed numbers, source-language residue, and altered instructions. Only then is a variant trained under the same budget as the baseline. The release advances if the target segment improves without degrading safety, document fidelity, or performance in the dominant language.

The Nemotron 3.5 report compares the checkpoint before and after a 100-billion-token continued-pretraining stage. Ten billion tokens come from a mixture of synthetic and natural Indian-language text; scores rise on all five benchmarks reported for that stage. The responsible reading is narrow: the combined stage is associated with those improvements in that model. It does not isolate the contribution of the synthetic corpus, does not show that 2.8 trillion tokens were consumed, and does not establish that the same recipe will work equally in another language, domain, or architecture.

Evaluation needs three layers. The first measures the sample: preservation of meaning, numbers, code, formatting, fluency, and script. The second measures the model: knowledge, reasoning, instruction following, and language quality by segment. The third measures the product: correct retrieval, safety, escalation rate, and human preference on real tasks. An improvement in the first does not guarantee the third, and a global metric can hide that the lowest-resource language became worse.

Two limits matter especially. In part of the published flow, the same model translates and judges, which may favor its own outputs; human review is sampled and coverage varies by language. Removing duplicates by processing identifier is also not the same as deduplicating semantically similar content. Both limits should become tests: an independent or human judge for calibration, and similarity search across provenance groups before splits are closed.

Adapt an open pipeline when the target language has little useful material, you own clearly licensed sources, and you can sustain competent review. Buy or contract capacity when data operations—not a differentiated recipe—are the bottleneck. Wait when no representative held-out set exists, derivatives cannot be separated across splits, or nobody on the team can judge the language and cultural context. Generating first and governing later turns compute cost into provenance debt.

This week's advance matters because it publishes an inspectable architecture at unusual scale and documents its limits. The mature decision is not to copy the volume or threshold. It is to adopt the discipline: traceable sources, separate candidates, calibrated acceptance, lineage-based splits, fixed-budget ablation, and reversible release. If those six gates fit the pilot, scale amplifies evidence; if they do not, it only amplifies errors that are hard to withdraw.