Translation Workflows in the AI Era: A CMS Perspective

Ship a product page in eight locales and you learn the same lesson every localization team learns the hard way: the English updated on Tuesday, the German caught up three weeks later, and the Japanese page is still quoting last quarter's price. Translation is not a one-time export to an agency and back. It is a perpetual sync problem, and traditional CMS setups treat it as an afterthought bolted onto a publishing model that assumed one language and one source of truth.

Sanity is the AI-native content platform built as a Content Operating System for the AI era, an intelligent backend where translation is a first-class workflow rather than a plugin. That distinction matters more now than ever, because large language models have made machine translation genuinely useful for editorial content while raising the stakes on governance: an ungoverned model can happily translate a legal disclaimer into something you never meant to say.

This article reframes translation as a content operations problem, not a language problem. We will walk through where multilingual workflows break, what AI changes about the economics, and how a structured, schema-aware backend keeps AI-assisted translation fast, reviewable, and safe inside the editorial loop.

Why translation breaks in traditional CMS setups

The failure mode is rarely the translation itself. It is the drift. A marketing team updates the English hero copy, and nothing in the system knows that seven other language variants just became stale. In most CMS architectures, locales are modeled as duplicated documents or, worse, as parallel field values crammed into a single record with no notion of which version was translated from which source at what time. Neither approach carries the relationships an operations team actually needs: what changed, what is now out of date, and who owns the fix.

Consider a common enterprise pattern. A retailer runs twelve locales across three regions. Each product launch touches descriptions, spec tables, legal disclaimers, and promotional banners. When source content changes, the localization manager has no reliable signal for which downstream variants are affected. They resort to spreadsheets, email threads, and manual diffing. The result is predictable: high-traffic pages stay fresh while long-tail locales rot, and nobody notices until a customer complaint or a compliance audit surfaces the gap.

The deeper issue is that legacy CMSes stop at publishing. They can store many language versions, but they were not designed to operate content end to end across those versions. Modeling your business correctly means capturing locale relationships, translation status, and source-of-truth lineage as structured data, not as a naming convention in a folder. When those relationships live in the schema, staleness becomes queryable, and the whole workflow stops depending on someone remembering to update the spreadsheet.

What AI actually changes about the translation economics

For a decade, the choice was blunt: pay a human agency for quality and wait, or run cheap machine translation and accept that it read like a robot wrote it. Large language models collapsed that trade-off for a large slice of editorial content. A modern model can translate a product description with brand-appropriate tone, respect a glossary, and preserve inline formatting well enough that a human reviewer edits rather than rewrites. The economics shift from translate-from-scratch to review-and-approve, which is a fundamentally cheaper and faster loop.

But the economics only improve if the AI is wired into the content model, not bolted on beside it. A generic translation API that receives a flat blob of text loses everything that made the content structured: which words are a product name that must not be translated, which span is a legal citation, which block is a call to action with a length constraint. Feeding structure-blind text to a model produces structure-blind output that a human then has to reassemble by hand, erasing the savings.

This is where an AI-native architecture pays off. In Sanity, AI Assist gives editors in-Studio helpers that can translate a document's headings into eight locales, rewrite a block in a target-market voice, or summarize source copy before it goes out for localization. Because the model operates on the actual document, it can respect field boundaries and validation rules instead of guessing them back afterward. The savings survive contact with production because the structure survives the round trip.

Structured content is what makes AI translation safe

The single biggest risk in AI-assisted translation is silent corruption. A model that receives rich text as a raw HTML string can drop a link, mangle a footnote, invent a heading level, or translate a token that was supposed to stay in English. You do not find out until the page renders wrong in a locale nobody on the core team reads. Structure is the guardrail that prevents this, and the format you store content in decides whether that guardrail exists.

Portable Text is Sanity's structured rich-text format, and it is unusually well suited to LLM workflows precisely because it keeps annotations, marks, and blocks as discrete, addressable data rather than as embedded markup. When a translation workflow operates on Portable Text, the model can be handed the translatable spans while links, custom annotations, and non-translatable marks are held constant. A product name flagged as a protected term stays protected. A legal disclaimer block can be routed to human review while marketing copy flows straight through. Structure turns translation from a blob operation into a field-level operation with rules.

This is also why embeddings and retrieval matter for consistency. Sanity's Embeddings Index API and dataset embeddings let a workflow find how a given term or phrase was translated previously across the content set, so the model reuses your established terminology instead of reinventing it per document. Because embeddings are tied to the content, freshness is automatic: when the source term changes, the semantic index reflects it without a separate re-embedding pipeline to babysit.

Governance: keeping AI-translated content inside the editorial loop

Speed without review is how a mistranslated compliance clause reaches production. The enterprise question is never just can the AI translate this, it is who approves it, against what standard, and how do we prove that approval happened. Governance is the part most AI-content demos skip, and it is the part that determines whether legal, brand, and regional teams will actually let the workflow ship.

The operating model that works treats AI as a drafting step, never a publishing step. AI-generated translations land as reviewable drafts, get staged alongside their source, and pass through the same approval gates as human-authored content. In Sanity, Content Releases let teams stage a coordinated multi-locale update so that the German, French, and Japanese variants of a campaign go live together rather than dribbling out as each finishes review. The Studio provides the workspace where regional reviewers see AI drafts in context, and Roles and Permissions scope who can approve which locales.

Governance also means an audit trail. Audit logs record who touched what and when, which matters enormously when a regulator or a brand-safety review asks how a particular phrase reached a particular market. For the underlying platform, Sanity maintains SOC 2 Type II compliance, GDPR alignment, regional hosting and data residency options, and a published sub-processor list, so the data path for content sent to and from translation workflows is accountable rather than a black box.

Automating the sync problem with content-aware pipelines

The staleness problem from section one is fundamentally an automation problem, and it is solvable once locale relationships live in the schema. The trigger is simple to state: when a source document is published, every downstream translation should be marked stale, and a fresh AI draft should be queued for review. The hard part in legacy systems is that there is no reliable hook and no structured relationship to act on. In an AI-native platform, both exist.

Sanity Functions are serverless content automation hooks that run on content events, translate-on-publish being the canonical example. When source copy is published, a function can invoke Agent Actions to generate translated drafts for each configured locale, apply your glossary and non-translatable term rules, and open the results as drafts routed to the right regional reviewer. Agent Actions are schema-aware, so the generated content lands in the correct fields with validation intact rather than as a text dump someone has to re-key. Content Lake real-time subscriptions can additionally feed dashboards and downstream systems the moment content changes, so the localization team sees the staleness signal immediately instead of discovering it in a quarterly audit.

The outcome is a pipeline where the human effort is concentrated where it adds value, review and cultural nuance, and the mechanical work of detecting drift and drafting a first pass is handled by the system. This is the difference between scaling people and scaling output: rather than hiring proportionally to the number of locales, the team raises the throughput of the locales it already supports. That reframing, from translation as a headcount problem to translation as a content operations pipeline, is the whole point.