What can a 740-million-parameter model do on your phone without the cloud?

A model that lives in your pocket

EmbeddingGemma 2 is a multimodal embedding model that fits on a phone. It turns text, images, audio, and video into comparable vectors without sending data to a server. The announcement arrived on October 6, 2026, from Google DeepMind. The model carries 740 million parameters and ships under an Apache 2.0 license. That license permits commercial use without asking permission. The previous version, released a year earlier, focused on text only. Developers downloaded it more than 20 million times. They built on-device search tools and privacy-first retrieval pipelines. The new version expands the same idea to code, images, video, and audio. All of it runs locally.

Modular architecture keeps memory low

The system consists of three pieces. A text core uses 270 million parameters. An optional vision encoder adds 170 million. An optional audio encoder adds 300 million. You load only what the task requires. Text-only workloads stay at 270 million parameters. Full multimodal support reaches the full 740 million. This design matters because phones have tight memory budgets. On a Google Pixel 11 Pro the quantized text-only weights need roughly 191 megabytes of active RAM. The full multimodal model needs roughly 567 megabytes. Those numbers come from the announcement's own measurements. They show the model fits inside the memory envelope of a flagship phone today.

Vectors you can shrink without retraining

Matryoshka Representation Learning lets developers truncate output vectors on the fly. The native dimension is 768. You can cut to 512, 256, or 128 dimensions at inference time. No retraining required. The announcement claims up to six times storage reduction for local vector databases. The trade-off is precision versus space. The developer chooses per use case. A photo search app might keep 768 dimensions. A keyword spotter on a watch might drop to 128. Both use the same model weights.

Context window grows fourfold

Version 1 offered a 2K token context window. Version 2 extends it to 8K tokens. That increase lets the model swallow larger chunks in one pass. The announcement translates tokens into media durations. Up to 5.5 minutes of audio. Up to 29 images. Up to 58 video frames. Or interleaved combinations of the above. All processed on local hardware. A voice memo of a meeting fits. A short video clip fits. A photo burst fits. Longer recordings still need chunking. The limit is hard. The document does not say whether sliding-window strategies are built in or left to the developer.

Benchmarks show gains where it counts

Code performance jumps 9.92 points on the MTEB Code benchmark. The score moves from 68.76 to 78.68. That makes the model suitable for local codebase indexing and semantic code search. Multilingual text performance matches the previous version. On vision and audio tasks the model sets a new quality-per-parameter bar for sub-1B models. It even outperforms some specialist models more than twice its size. The announcement cites MTEB Code and MAEB (Massive Audio Embedding Benchmark) as the primary benchmarks. Full evaluation metrics live in the model card. The document does not publish raw scores for every language or every audio task. It summarizes the headline deltas.

Runs where you already build

Weights sit on Hugging Face and Kaggle. Gemini Enterprise Agent Platform Model Garden access is coming soon. LiteRT Community on Hugging Face hosts on-device optimized variants. For deployment you pick a path. Google AI Edge MediaPipe gives turnkey embedding, retrieval, and decision tasks. LiteRT handles custom model integration. Browser targets use transformers.js or WebGPU. Server-side serving works with transformers, sentence-transformers, MLX, vLLM, llama.cpp, SGLang, Ollama, and LMStudio. Vector storage plugs into Qdrant. Fine-tuning guidance comes from Unsloth. A developer guide, documentation, and inference and fine-tuning guides round out the package. The list of tools is long because the ecosystem is fragmented. The announcement does not benchmark latency across all those runtimes. It only states the model works with them.

Demos show the intended loops

A trio of reference apps illustrates the design. Google AI Edge Gallery Instant Media Search lets you use text or an image to find matches in a media library. Video Moments Finder locates specific moments in video using text or audio queries. The Foresight app pairs EmbeddingGemma 2 for local file retrieval with Gemma 4 for contextual reasoning. A fourth piece, the MediaPipe Decision Task API, targets real-time decision engines. Classification, routing, and predictive capabilities run on multimodal context. These demos are not benchmarks. They are existence proofs. The document does not publish latency numbers for any of them. It does not say whether they run at 30 frames per second or one frame per second on a Pixel 11 Pro.

What the announcement leaves open

The model card holds the full evaluation metrics. The announcement points there but does not reproduce them. Quantization recipes for each runtime are not detailed in the post. The 191 MB and 567 MB RAM figures apply to a Pixel 11 Pro with quantization. Other devices will differ. The document does not specify the quantization scheme (INT4, INT8, mixed). It does not state whether the vision and audio encoders can run independently of the text core at inference time. The modular parameter counts suggest they can. The text says "optional" encoders. It does not show the API for loading them separately. Fine-tuning guidance exists via Unsloth. The announcement does not describe data requirements or compute budgets for fine-tuning. It does not mention whether the Apache 2.0 license extends to fine-tuned derivatives. The previous version saw 20 million downloads. The announcement does not break down how many of those were unique projects versus repeated CI pulls. It does not disclose training data sources or carbon footprint. The model is built on Gemma 4 architecture. The announcement does not detail what changed between Gemma 4 and the embedding specialization. It shares the text tokenizer and audio encoder with Gemma 4. That sharing lowers combined memory when both models run together. The exact combined footprint is not given. The 8K context window is four times the previous version. The document does not say whether positional embeddings are rotary, learned, or relative. It does not discuss extrapolation beyond 8K tokens. The MRL truncation dimensions are fixed at 512, 256, 128. Intermediate dimensions are not mentioned. The six-times storage reduction claim assumes 768 to 128. Real-world reduction depends on index overhead. The announcement does not provide index size measurements. The MediaPipe Decision Task API is referenced. Its documentation lives elsewhere. The post does not explain how it fuses embeddings with decision logic. The Foresight app pairs retrieval with Gemma 4 reasoning. The latency budget for that pipeline is not published. The model is described as best-in-class for its size. The comparison set is sub-1B multimodal embedders. Larger models are not the primary benchmark. The claim "outperforms some specialist models more than twice its size" names no models. The model card may. The announcement does not.