No Signal, Still Talking: Google Brings Offline Voice to AI Edge Gallery
Google put on-device speech recognition and text-to-speech into AI Edge Gallery on November 10: the phone listens and speaks entirely offline, with no server and no usage bill. The 10x real-time transcription, 100 ms time to first speech, and 0 MB added to your APK are real — but all of them are Google-reported, and 0 MB applies to the Android path only.

Talking to your phone with no signal at all
On November 10, Google announced on its developers blog that Google AI Edge Gallery now supports Automatic Speech Recognition (ASR) and Text-to-Speech (TTS) that run entirely on device, completely offline. No network, no server, no "uploading audio" indicator — the phone listens by itself and speaks by itself. Paired with on-device small language models (SLMs) like Gemini Nano and Gemma 4, a single phone can run a whole local voice pipeline: you speak, it transcribes in real time; the model works out an answer, and it reads the answer out loud on the spot. It sounds like a small feature. It is actually a gear change for on-device AI — voice interaction no longer depends on the cloud.
Why does this deserve its own article? Because for people who build apps, the word "offline" rewrites three things. First, the setting: subways, airplanes, underground car parks, villages with one bar of signal — places where voice features used to be decorative now work. Second, cost: voice requests no longer pass through a server, so the more you use them, the more you save, and a small team does not need a separate voice bill. Third, privacy: audio never leaves the device, which for apps that handle sensitive conversations — medical notes, children's learning, business meetings — is not a bonus but a requirement for entry. Google's release covers all three at once: setting, cost, and privacy, delivered together.

Two paths: ML Kit for Android, MediaPipe for cross-platform
The release gives developers two paths. Pick by target platform; there is no need to agonize over choosing one.
The first path is Android, using ML Kit. Google's latest on-device speech models are integrated into the OS: speech recognition covers 100+ languages and transcribes at 10x real-time speed, and the paired TTS model is a few-step diffusion model that begins speaking in just about 100 ms and synthesizes 24 kHz audio at up to 50x real-time speed. The key line is this: both models are integrated into the OS, adding 0 MB to your APK. The models are managed through AICore and Google's on-device speech services, so developers do not handle model downloads or worry about APK size bloat; apps also benefit automatically from hardware acceleration across NPU and TPU backends when available, and seamless background model updates. On accuracy, Google's figures are a Word Error Rate of 8.0% to 9.0% on FLEURS, about 300 ms to transcribe 3 seconds of speech, and end-to-end speech translation wait times cut by 35% to 44%. On synthesis: 8 expressive voices and 21 locales, a 27-second paragraph synthesized in just about 500 ms, active device power cut by over 50% compared to traditional autoregressive TTS models, and built-in earcon support.
The second path is cross-platform, using MediaPipe Tasks and LiteRT. Integrating ASR and TTS into cross-platform apps usually requires handling low-level audio framing, Voice Activity Detection (VAD), and complex decoding pipelines; MediaPipe Tasks abstracts all of that into simple, high-level interfaces across iOS, macOS, Windows, Linux, and Web. The Speech Recognition Task automatically handles audio framing, configurable VAD, and decoding, and supports real-time streaming, full-sentence batch, and hybrid transcription modes — streaming live words as you speak and refining the full sentence once speech ends — with the open-weight Parakeet-TDT 0.6B model out of the box, which you can try directly in the browser. The Text-to-Speech Task provides a turnkey synthesis interface with voice selection and low-latency streaming audio output, showcasing open-weight models out of the box, including multilingual models like PocketTTS 100M and Kokoro-82M, as well as the ultra-lightweight English model Phonon 31M, with sub-100ms Time-to-First-Audio (TTFA) on most devices and platforms.
Both paths run on the same foundation: LiteRT, Google's high-performance on-device AI inference infrastructure. Speech models often rely on multiple subgraphs and auxiliary assets — encoder/decoder subgraphs and tokenizers for ASR, or phonemizer dictionaries, voice embeddings, and vocoders for TTS — and all required components for each model are packaged into a single .litertlm file for easy deployment. The app ships with ready-to-use .litertlm models: Parakeet-TDT-0.6B-v3 for multilingual ASR, PocketTTS 100M for multilingual TTS, Phonon 31M for ultra-lightweight English TTS, and Kokoro-82M for multilingual TTS. Beyond these, the Hugging Face LiteRT Community, with over 10,000 followers, offers a growing catalog of open-weight models, like Whisper, Qwen3-ASR, and Moonshine for ASR, or Qwen3-TTS and Matcha for TTS. Cross-platform applications that need finer-grained control or custom model architectures can also build directly on LiteRT.
XR Language Teacher: a demo built to prove it is really offline
The most convincing part of the release is not the spec sheet but a demo: the XR Language Teacher. The situations where you most need language learning with voice are exactly the situations with the least connectivity — in underground stations, busy markets, or abroad where Wi-Fi and roaming data may not be available. Google built a showcase in AI Edge Gallery: point your camera at an unfamiliar object or menu, ask "What is that, and how do I ask for one?", and immediately hear an explanation in your language alongside authentic pronunciation in the local language. The whole interaction runs 100% locally on your phone, with no network connection needed.
Here is how the pipeline runs: on-device ASR streams your spoken question in real time, and alongside the camera frame it goes to Gemini Nano on Android devices — or Gemma 4 across other platforms — in a single pass. The model uses a structured output schema to explain the scene in your own language while tagging foreign-language phrases separately, allowing the TTS pipeline to seamlessly switch voices and accents mid-sentence from your mother tongue to the target language, alongside an on-screen vocabulary card. The same experience extends to smart glasses, with inference running locally on a paired phone: it works standalone on a phone and extends naturally to hands-free smart glasses. Google covered the adaptation for intelligent eyewear in a talk at Android Dev Summit, "Building Audio-First Experiences for Intelligent Eyewear with Gemini Nano."
The demo is worth studying because it proves three things at once. First, speech, vision, and language models can run together on one phone without fighting each other for compute — in Google's words, they run "in a compact memory footprint" and "without compute contention" alongside on-device SLMs. Second, structured output is not just "nice formatting": it is the key to bilingual voice switching, because without the schema tagging, foreign phrases could not get their own voice. Third, offline is not a degraded mode: nothing in the demo carries a "fewer features because offline" compromise — live transcription, visual grounding, and bilingual read-aloud are all there. Together, those three points are what "offline voice" really means as a product: not a backup for when the network fails, but the way it should run in the first place.
AI Chat gets a voice too: read-aloud has to keep up with the sentence
Beyond XR Language Teacher, Google also built ASR and TTS directly into AI Edge Gallery's main AI Chat feature, giving on-device SLMs like Gemini Nano and Gemma 4 a natural, offline voice interface while on the go. Three implementation details are worth learning from.
First, sentence-synchronized playback. Turn on "Auto-play TTS" or tap the speaker button on any response, and a floating TTS bar launches that highlights each spoken sentence in real time, with the ability to jump to any sentence by tapping it. This is not "read the whole paragraph and be done with it" — it is "highlight where you are as you read," so the user can interrupt, jump, or replay at any moment. Voice settings are managed centrally too: in Model Management you can choose between available ASR and TTS pipelines, preset voices, and downloaded language packs in one place.
Second, the dirty work hidden in the reference implementation. Google's open-source code demonstrates how to handle the most annoying details of read-aloud: strip Markdown syntax, skip non-spoken blocks like code snippets and tables, and schedule synthesis at the sentence level to avoid compute and memory contention during LLM token generation. Each of these details looks small on its own; together they are the difference between "read-aloud that works" and "read-aloud that stutters, reads code out loud character by character, and recites tables word by word." Many teams add voice to chat and stop at "it makes sound." Google open-sourced the version that already stepped on the rake.
Third, honesty about architecture. The blog states it plainly: while multimodal models like Gemma 4 can process audio inputs directly, Google still provides a modular solution — cascading language models with separate, lightweight voice models — for latency optimization and flexibility. In other words, do not cram everything into one big model; let small models each do their own job: the speech models listen and speak, the language model thinks. That "cascade" thinking matters most on resource-constrained devices, and it is the most copyable idea in the whole release for vibe projects building voice features: do not wait for one omnipotent model, assemble a pipeline where each part does its own job.
What it means for vibe projects: voice is no longer a big-company privilege
Until today, adding voice to an app usually meant three things: signing up for a cloud vendor's speech API, paying per use, and sending user audio to a server. Every one of those is unfriendly to small teams: the API costs money, audio in the cloud has to pass privacy review, and offline use simply does not work. The point of Google's release is that it takes all three costs to zero at once: the ML Kit path is integrated into the system with no APK size increase, the MediaPipe path is open models plus single-file deployment, and neither path needs a server, generates a usage bill, or lets audio leave the device.
What can you actually build? Start with the three most direct scenarios. First, apps where you have to talk with no signal: travel translation, offline dictionaries, field notes, classroom assistants — users need voice most exactly where there is least connectivity. Second, apps where audio is sensitive: children's learning, medical visit notes, meeting minutes, personal journals — with audio never leaving the device, compliance and user trust are both easier. Third, apps where voice is the main interface: driving, cooking, exercising, working with gloves on — when your hands are busy, voice is the interface. In all three, voice is not a nice extra; it is what makes the product work at all.
But the limits of the release deserve the same attention. First, every number is Google-reported: the 8.0% to 9.0% Word Error Rate, the 10x real-time transcription, the 50x real-time synthesis, the 50%+ power reduction — the post cites no independent measurements, and real-world results will vary by device, accent, and background noise. Second, the "0 MB added to your APK" claim applies to the Android ML Kit path only; the cross-platform path still requires downloading .litertlm model bundles before first use. Third, the "thinking" power of on-device small models is still limited: Gemini Nano and Gemma 4 handle narrower conversations and reasoning than cloud models. The voice pipeline solves "hearing and speaking," not "thinking deeply." An offline voice assistant can transcribe and read aloud fluently, but its ability to answer hard questions is still bounded by the on-device model itself.
One more judgment is worth recording: the real competitor for offline voice is not cloud voice, it is "no voice at all." Many small apps still have no voice feature, not because their builders do not want one, but because the combined cost of a cloud API, compliance review, and the offline gap is too high. Google has now taken down all three barriers at once, turning voice from a "big-company standard" into a "default feature a small team can add." What remains to be seen is how many vibe projects actually use it — not in a demo, but in subways, kitchens, and on running tracks.
Where offline voice still falls short of cloud voice
At this point, one question deserves a direct answer: where does offline voice actually fall short of cloud voice? The answer has three layers. The first layer is recognition in hard environments: in a quiet room, with a standard accent and short sentences, on-device models are already close to the cloud; but on a noisy street, with accented long sentences, or in a meeting room where several people talk at once, the on-device error rate rises sharply — the 8.0% to 9.0% Word Error Rate in the blog was measured on the FLEURS benchmark, and real-world numbers will only be higher, not lower. The second layer is depth of understanding: speech recognition only solves "what was heard," and the hard part is "what was meant" — when a user says something vague, a cloud model can use broad context to guess the meaning, while an on-device small model has far narrower context to draw on. The third layer is expressiveness of the voice: 8 voices and 21 locales sounds like a lot, but compared with cloud synthesis that can mimic tone, pauses, and emotion, on-device speech still sounds more like a "standard announcer voice" — good for reading aloud and giving prompts, not for telling stories or playing dialogue.
These three gaps define where offline voice fits: it suits scenarios that are "easy to hear, shallow to think, short to say" — voice input, read-aloud, simple voice commands, and pronunciation demos for offline translation. It does not suit scenarios that are "hard to hear, deep to think, long to say" — multi-person meeting transcription, dialect and accent recognition, and long emotional read-aloud. Those still need the cloud today, or a stronger generation of on-device models. The test for your own app is simple: take the three sentences your target users say most often, and try them in real environments — in the subway, at a market, in a room with a fan running — and only if recognition holds up should you talk about shipping; if it fails, do not rush to launch.
There is one more cost that is easy to overlook: the first download. The .litertlm model bundles on the cross-platform path have to be downloaded before first use — Parakeet-TDT 0.6B, PocketTTS 100M, and the rest are not large, but for users on storage-tight low-end phones, a download of several hundred megabytes is a real barrier. Handle it well in the product: only download when the user taps a voice feature for the first time, never bundle everything at install; when downloading, say how large it is, how long it will take, and whether it can wait for Wi-Fi; when it finishes, say "voice is ready — it works without a connection from now on." Done well, users feel "the wait was worth it"; done badly, they uninstall the app while staring at the progress bar.
Getting started: three things you can try today
The blog's getting-started path is concrete, in three steps. First, experience it: download the latest Google AI Edge Gallery app on Android and iOS, and try XR Language Teacher and voice-enabled AI Chat on your own device — see for yourself how offline voice actually performs on your phone, including whether recognition is accurate, whether read-aloud sounds natural, and whether the latency is acceptable. Second, adapt the code: check out the reference implementation in the Google AI Edge Gallery GitHub repository, or point your favorite coding agent, such as Google Antigravity, at the repo to quickly adapt the streaming ASR, bilingual TTS code-switching, and sentence-synchronized playback pipeline for your own app. Third, pick your interfaces by platform: explore the ML Kit GenAI Speech Recognition and Text-to-Speech documentation for Android integrations, MediaPipe Tasks for turnkey cross-platform APIs, or follow the LiteRT developer guide and download ready-to-run .litertlm bundles from the Hugging Face LiteRT Community; to test and benchmark your on-device voice pipelines, Google Cloud's Developer Device Platform offers 200+ real physical devices.
For independent developers, the first step is the one to do first: do not start by reading documentation, start by trying it on your own phone. For offline voice, no number on a spec sheet — 10x real-time, 100 ms to first speech, 8.0% Word Error Rate — is as convincing as trying it once yourself: say a sentence in the subway and watch it transcribe live, have it read an answer aloud on a noisy street and hear whether you can follow it. Once you have tried it, decide whether your app needs voice, and which kind. The good thing about this release is that trying it costs almost nothing: the app is free, the models are ready, the code is open source. The only thing left is your time.
Comments (0)
Sources
Related articles
On 20 November 2026, Thinking Machines Lab released Inkling 2 Mini: a 26.4B-parameter looped transformer that runs its middle 12 layers three times per token, fits in about 20GB, and runs offline on a laptop. It leads open-weights models of its size on DeepSWE and SWE-bench Verified — with the caveats printed in the same announcement.
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.