Google's Gemini 3.5 Live Translate Kills the 3-Step Pipeline for $0.023 a Minute
Google's Gemini 3.5 Live Translate drops the old STT-MT-TTS pipeline for a single end-to-end audio model covering 70+ languages at $0.023/min
- New model: Gemini 3.5 Live Translate is a single end-to-end audio model replacing the old STT-translate-TTS pipeline for real-time speech translation.
- Coverage: Supports 70+ languages and 2,000+ language pair combinations with automatic language detection, no manual config needed.
- Latency: Median first-audio latency of ~3 seconds; translates continuously as the speaker talks rather than waiting for turn boundaries.
- Pricing: $0.023 per minute via the Gemini Live API, undercutting competing real-time translation APIs.
- Availability: Public preview for developers via API and AI Studio; rolling out now in Google Translate (Android/iOS); Google Meet enterprise private preview.
- Limitations: Audio-only input, no tool use or system prompts; voice consistency can drift in multi-speaker sessions or after long pauses.
Real-time speech translation has been a solved problem on paper for years. In practice, it has always felt like a game of telephone: your voice gets transcribed to text, that text gets machine-translated, and the result gets synthesized back into speech. Every handoff adds latency and a new surface for errors to compound. Gemini 3.5 Live Translate collapses that three-step cascade into a single end-to-end audio model, and the difference is audible.
The pipeline problem it actually solves
Older real-time translation systems, including Google Meet's previous implementation, ran a cascaded three-step pipeline: transcribe speech to text (STT), translate that text, then synthesize the translated text back to speech (TTS). Each hop adds latency and a place for errors to compound -- a mistranscription becomes a mistranslation becomes a confidently wrong spoken sentence.
Three architectural choices distinguish Gemini 3.5 Live Translate from earlier streaming-translation systems. Traditional pipelines run audio through a streaming speech-to-text model, feed the transcript to a machine-translation model, then synthesize the translation through a separate text-to-speech model. Each stage adds latency and accumulates errors. The new model fuses all three stages into one, processing the raw audio stream directly.
Unlike turn-by-turn systems that wait for the speaker to finish speaking before responding, 3.5 Live Translate generates speech continuously, balancing the trade-off between waiting for context to improve quality and translating immediately to stay in sync with the speaker. The result is a translation that stays just a few seconds behind the speaker throughout the session, with no awkward pauses between utterances.
What it's built on
Developers can access the model via the Gemini Live API and Google AI Studio, currently in public preview. According to the official model card, Gemini 3.5 Live Translate is part of the Gemini 3 family of models, and is specifically based on Gemini 3 Pro. The model takes raw audio in and outputs raw audio -- there is no text intermediary in the core translation path, though you can optionally request text transcripts of both input and output for debugging.
The model was evaluated across three main quality dimensions: translation quality, latency, and speech naturalness. Translation quality uses AutoMQM -- an error-based automatic metric which identifies and categorizes translation errors to produce a fine-grained quality score. These metrics are applied across a variety of language pairs and content types to assess the accuracy and adequacy of the translated output.
The numbers that matter
First-audio latency sits at a median of 2,947 ms from start of speech to first translated audio (p10-p90: 2,859-3,104 ms). This is a consistent ~3-second speaking delay, in line with Google's "a few seconds behind" framing. That is not zero, but it is consistent -- and consistency is what makes real-time conversation feel natural rather than broken.
The key capabilities the model ships with:
- 70+ languages, 2,000+ pairs: Google's new model covers more than 70 languages and 2,000+ language combinations.
- Auto language detection: The model handles multilingual inputs without the need to manually configure settings.
- Voice preservation: It preserves intonation, tempo, and vocal pitch, so the translated voice sounds closer to how the original speaker actually sounds, rather than flat synthesized audio.
- Noise robustness: Google says the model handles background noise and overlapping voices, making it usable in real-world settings like busy cafés or open offices.
- SynthID watermarking: Every audio output is watermarked using Google's SynthID technology, embedding an invisible marker in the audio to flag it as AI-generated.
Where it falls short
The model card is honest about the rough edges. Voice replication can be inconsistent. Voices might shift after long pauses, assign the wrong gender based on how the speech starts, or get stuck on one voice during rapid multi-speaker conversations. Language detection struggles with heavy accents, similar languages (e.g., Spanish vs. Portuguese), or rapid language switches.
There is also a hard architectural constraint worth knowing: for developers, the translation API call is a constrained surface -- you cannot send text, you cannot use the broader Gemini tool ecosystem, and you cannot inject system prompts. Translation in, translation out. This is by design -- the latency guarantees depend on keeping the pipeline narrow -- but it means you cannot bolt on custom instructions or function calling the way you can with the standard Live API.
How to start building
The API model ID is gemini-3.5-live-translate-preview. You stream raw 16-bit PCM audio at 16kHz in 100ms chunks and receive translated audio back at 24kHz. Here is the minimal Python setup:
from google import genai
from google.genai import types
client = genai.Client()
config = types.LiveConnectConfig(
response_modalities=["AUDIO"],
input_audio_transcription=types.AudioTranscriptionConfig(),
output_audio_transcription=types.AudioTranscriptionConfig(),
translation_config=types.TranslationConfig(
target_language_code="es", # BCP-47 code for Spanish
echo_target_language=True # pass-through if input is already Spanish
)
)
async with client.aio.live.connect(
model="gemini-3.5-live-translate-preview",
config=config
) as session:
# stream audio chunks and receive translated audio
passThe echo_target_language flag controls what happens when the input is already in the target language: set it to True to pass the audio through, or False to stay silent. For browser-facing apps, use ephemeral tokens to avoid exposing your API key client-side.
At $0.023 per minute with 70+ languages, Gemini 3.5 Live Translate undercuts OpenAI on price. For a one-hour multilingual meeting, that works out to roughly $1.38 -- a number that makes previously cost-prohibitive use cases like per-call translation in consumer apps suddenly viable.
Three surfaces, one model
The launch covers three product surfaces in parallel: developer access via the Gemini Live API and Google AI Studio (public preview); consumer access through the Google Translate app on Android and iOS, rolling out globally, with a new "listening mode" on Android; and enterprise access through Google Meet in private preview for select Google Workspace customers, where it expands Meet's translation coverage from 5 languages to 70+ and supports over 2,000 source/target combinations within a single meeting.
Android users get a new Listening Mode: hold the phone to your ear like a normal call and hear a private translation through the speaker -- no earbuds needed. It is a small UX detail that opens up a lot of real-world scenarios, from guided tours to airport check-ins.
On the ecosystem side, developer platforms like Agora, Fishjam, LiveKit, Pipecat, and Vision Agents enable developers to build and deploy voice translation apps with ease. These integrations handle the complex real-time media streaming infrastructure, so developers can focus on the user experience. Grab is testing the model to enable multilingual communication in near real-time between drivers and travelers at pickups -- a user base that makes over 10 million voice calls per month.
What this changes for the field
The real shift here is not the language count or the latency number in isolation. It is that a production-grade, end-to-end speech-to-speech translation pipeline is now a few lines of Python and $0.023 per minute. Real-time speech translation is moving from demo feature to developer API and consumer workflow, which matters for meetings, customer support, travel, education, and multilingual products.
A courtroom interpreter, a medical consultation, and a family dinner do not have the same tolerance for delay or approximate meaning. A model tuned for natural conversation may not be tuned for legal precision. A model tuned for low latency may make more early structural choices. Live translation is a latency-quality negotiation, not a solved state. The model is in preview, and the official docs are the right place to verify current specs before any production rollout. But the direction is clear: the infrastructure cost of multilingual voice just dropped by an order of magnitude.