AI_TRANSLATE: Translating Long Texts Without Losing the Plot

Translating a long report, policy paper, or transcript without losing completeness, structure, and meaning presents a distinct challenge. As documents grow in length and complexity, maintaining consistency and context becomes harder, and that's where traditional translation services often start to break down.

Short-form translation is already an important part of many workflows, from product reviews and descriptions to support content. In addition to these use cases, organizations also need to process and translate much larger materials at scale. These include annual reports, board materials, research papers, long meeting transcripts, regulatory, and other documents. These are not just longer versions of a short-form task. They are complex, dense document artifacts filled with tables, captions, lists, footnotes and sections where even small omissions matter.

Traditional tools, LLMs and managed APIs often struggle to process long content with high accuracy. This is why the Cortex AI Function, AI_TRANSLATE, is designed to handle translation workloads regardless of size, extending enterprise-grade translation natively to long-length content.

Why long-context translation is a different problem

When people think about translation quality, they usually think about fluency: Does the output sound natural? But for many business documents, that is only a small part of the story. The real story relies on a much harder question: Can the system stay faithful all the way through?

High-accuracy translation on long content requires a system capable of:

• Enabling full document coverage from the first page to the last.
• Preserving section structure and complex formatting.
• Understanding high-stakes data, such as numbers, names, dates, units and references
• Capturing the details, including lists, tables, notes and side content that are easy to skip

This is where long documents expose weaknesses of traditional systems. A translation can sound perfectly smooth while quietly dropping critical details in the middle. It can handle the main narrative but completely stumbles on figure notes and tabular commentary. For a 100-page document, these omissions are nearly impossible to catch manually.

Why many managed translation APIs hit a limit

One of the biggest bottlenecks in document translation is simple request size. Traditional translation APIs are designed to excel at processing short text messages, but long documents exceed what fits comfortably into a single request, forcing teams to build complex chunking and orchestration pipelines.

Here is a practical high-level view of common input limits:

This matters because a standard annual report or hearing transcript can easily run into hundreds of thousands of characters. Once you are forced to split long documents into chunks, stitching the document back together seamlessly becomes an engineering headache.

This is the core of the challenge our customers ask us to simplify for them. They want to be able to use AI_TRANSLATE to translate documents of any length in a single query, without the overhead of building and maintaining orchestration pipelines.

Experimental comparison

• To test this tradeoff, we ran an experimental comparison translating non-English documents (200k–450k characters) into English. AI_TRANSLATE processed the documents natively in a single call, while we forced AWS and Google Cloud to use naive chunking aligned with their limits.

Setup:

• Snowflake AI_TRANSLATE translated each document natively in a single long-context call.
• AWS Translate translated the same documents with naive 7,500-character chunks, chosen to stay within its practical per-request limit.
• Google Cloud Translation v3 translated the same documents with naive 30,000-character chunks, aligned with its documented maximum request size.

It is also worth emphasizing that Snowflake's AI_TRANSLATE handles long documents out of the box. With the other managed APIs, the user has to build that workflow themselves: choose a chunking strategy, implement the splitting logic, preserve boundaries and separators, and stitch the translated chunks back together. They also need to handle partial failures and decide how to recover from them before producing the final output. That is exactly the kind of plumbing a managed service is supposed to remove. With AI_TRANSLATE, the interface stays simple: call the function, and the long-context orchestration is handled for you.

We then evaluated the resulting translations with an LLM-as-a-judge, focusing on long-document translation behavior rather than only sentence-level fluency.

Methodology

Scores below come from Claude Opus 4.6 as an LLM-as-a-judge. The inputs are OCR text in the documents' original language, produced by AI_PARSE_DOCUMENT from long documents on government webpages; the task is to translate the text into English. This comparison covers synchronous real-time API performance only; AWS also supports asynchronous batch translation for larger workloads through a separate API path, which is not evaluated here.

Metrics:

• Completeness: measures whether the translation covers the full source document rather than shortening, skipping or compressing parts of it.
• Faithfulness: measures whether the translated content preserves the meaning of the source without adding distortions or losing important details.
• Coherence: measures whether the translation reads as a well-formed, internally consistent document from start to finish.
• Term consistency: measures whether important names, concepts and repeated terminology are translated consistently across the whole document.
• Long context quality: overall translation quality across the full document, computed as the mean of the four metrics above.

On this subset, AI_TRANSLATE leads on completeness, faithfulness, and term consistency, while Google is slightly stronger on coherence. AWS performs meaningfully worse on all four core quality dimensions, which is consistent with the operational reality that once you are forced to split long documents into small chunks, stitching the document back together degrades the quality of the translation.

Pricing comparison

Pricing matters most on the longest documents. A typical 100-page English document contains roughly 180,000 to 400,000 characters. Once you start processing many documents at that scale, the per-character price becomes a major factor.

* Assumes $2 per AI credit with global routing. The range reflects differences in characters per token across languages; English generally corresponds to the lower cost per 1M characters.

In this comparison, AI_TRANSLATE delivers the lowest cost at equivalent quality: under $3.26 per million tokens at the highest language-complexity scenario, while also requiring the least implementation effort.

Why general-purpose LLMs are not a complete answer

A natural reaction is to ask: What about long-context LLMs? While some models solve the input length issue, they introduce an entirely different class of problems on the output side.

Translation often expands the length of the text. When an LLM's output context is limited, it runs out of room. In our testing, we saw models visibly truncate mid-sentence. In one case, the translation simply ended in the middle of a sentence:

Worse than visible truncation is silent compression. This is one of the trickiest failure modes in long translation. The output remains highly readable, but the model softens, collapses, or drops detail to save space. Sometimes, the model simply decides to stop translating and summarize instead:

While readable, that output is not a translation; it's an incomplete summary.

The same pattern plagues heavily structured documents. Models will often translate the main narrative perfectly, but quietly drop or simplify the footnotes, chart notes, captions and labels. For a reader making business decisions, those lost details matter. A polished narrative cannot mask an unfaithful translation.

What happens as documents get longer

The same pattern also shows up when you step back from individual examples and look at long documents bucketed by length.

At around 150k-200k characters, several strong general-purpose LLMs are still competitive. But as documents get longer, their completeness becomes more erratic. AI_TRANSLATE holds a much steadier line, and beyond 250k characters it is the strongest system in every populated bucket we tested.

One way to make that tradeoff more concrete is to look at the 400k-500k range, where long-document behavior is especially visible:

* Assumes $2 per AI credit with global routing.

That matters because long-document failures are not always dramatic. Sometimes a translation stops early. Sometimes it keeps sounding fluent but starts compressing later sections or dropping lower-visibility material. As sequence length grows, completeness becomes harder to preserve, and that is where a purpose-built translation system starts to matter most.

What long-context AI_TRANSLATE is meant to solve

AI_TRANSLATE is built to make long-document translation dependable, not just possible. In practical terms, that means three things:

1. Native handling of long inputs:

You can pass massive documents directly into a single query with AI_TRANSLATE without building awkward manual splitting pipelines or custom orchestration. Your files stay intact, and operational complexity drops.

2. Designed to preserve completeness:

AI_TRANSLATE is intended to translate the document faithfully rather than "helpfully" rewrite it into a shorter form. If a system translates the first 80 pages beautifully and loses the last 20, that is not a successful translation. If an input is accepted, AI_TRANSLATE allocates sufficient output space to generate the full translation, designed to avoid silent failures or dropped appendices.

3. Keep things extremely simple:

The long-context path is not a separate product or a complex new infrastructure to manage. It brings translation directly to where your data already lives. There is no need to move data, manage API limits or turn every document into a custom workflow. It extends the core AI_TRANSLATE experience in a single query, natively handling mixed languages, untranslated brand names and the messy formats of real-world enterprise reporting. We believe that a useful translation system needs to handle any content input without the need for custom workflows by content type.

What good long-context translation looks like

The real test of a translation system boils down to: Can your team use the translated document the exact same way they would use the original?

If it's an annual report, analysts need to trust the tables and footnotes. If it's a policy transcript, legal needs the exact progression of the discussion. Sentence quality matters, but for long documents, it isn't enough. What matters is that the document remains a complete, trusted and usable asset.

With AI_TRANSLATE, your documents aren't just translated; they are activated, at scale, without losing the plot.