Gemma

Gemma is Google’s family of open-weight AI models for developers who want more control over how a model is deployed, customized, and integrated into an application. Rather than functioning as a finished assistant, the family provides downloadable models that can be run locally, deployed in the cloud, or adapted for specific workloads.

The current general-purpose generation is Gemma 4. It spans several model sizes and hardware targets, with support for long context windows, multimodal inputs, customization, and multiple deployment routes. Google also maintains specialized models for tasks such as embeddings, translation, function calling, safety classification, and medical AI.

That flexibility is one of the family’s main strengths, but it also creates complexity. Capabilities, memory requirements, licensing, privacy, cost, and deployment options can all depend on the exact model and serving method you choose.

What Is Gemma?

Gemma is a family of downloadable AI models developed by Google DeepMind and other Google teams. Google describes them as “open models,” built from research and technology related to Google’s Gemini work while remaining a separate model family.

Gemma and Gemini are not interchangeable. The former gives developers access to model checkpoints that can be deployed and adapted under their applicable licenses. Gemini is a separate model family commonly accessed through Google-managed products and services.

This makes the open-weight family primarily a development building block. Developers can choose the checkpoint, runtime, hardware, hosting environment, quantization, and application architecture around it.

The models themselves do not provide a complete assistant experience with built-in browsing, memory, retrieval, connectors, or external tools. Those capabilities depend on the software surrounding the model.

Gemma 4: The Current Model Family

As of October 18, 2026, Gemma 4 is Google’s current general-purpose generation. Google documents five main sizes:

All five models generate text. The family also supports visual input, including images and documented video-processing workflows, while E2B, E4B, and 12B additionally support audio. This is multimodal understanding rather than native image, video, or speech generation.

Google releases pretrained and instruction-tuned checkpoints. It also provides quantized formats for selected deployment paths.

The parameter counts require some care. The 26B A4B version, for example, is a mixture-of-experts model with 3.8B active parameters, but its full model is much larger. Active parameters should not be interpreted as the amount of memory required to store the model.

What Can Gemma Do?

The models can support text generation, summarization, question answering, extraction, coding, reasoning, multilingual tasks, structured output, and multimodal understanding. Selected variants can process audio, while supported checkpoints can work with visual information including images and sampled video frames.

They can also form part of a tool-using or agentic application. The model can generate structured requests for functions, but the surrounding application must provide the tools, permissions, validation, execution loop, and state management.

The same applies to retrieval-augmented generation. A model can use retrieved information supplied in its context, but indexing, embeddings, storage, document permissions, and retrieval are separate parts of the application.

Specialized Gemma Models

Google has expanded the family beyond its general-purpose models with several specialized branches.

EmbeddingGemma 2, released on October 6, 2026, creates multimodal embeddings for search, retrieval, classification, and clustering rather than generating conversational answers.

FunctionGemma focuses on function calling and is intended for task-specific adaptation. TranslateGemma targets translation, while ShieldGemma provides safety-classification models.

MedGemma is designed for medical AI development and has separate Health AI Developer Foundations terms and domain-specific limitations. Other branches include PaliGemma for vision-language adaptation, T5Gemma 2 for encoder-decoder research and customization, and the experimental DiffusionGemma branch.

These are separate models with their own purposes and, in some cases, different licensing conditions. Their capabilities should not be presented as features included automatically in the general-purpose generation.

Can You Run Gemma Locally?

Yes. Local and self-hosted deployment is one of its clearest differentiators from fully managed AI services.

Google documents deployment routes using technologies such as Ollama, LM Studio, llama.cpp, MLX, LiteRT-LM, Hugging Face Transformers, Keras, JAX-based tooling, vLLM, SGLang, and Google Cloud infrastructure. Support varies by checkpoint, runtime, modality, and format.

Running locally also needs a precise definition. Downloading weights only puts the model files on a device. Local inference means the model actually processes prompts on that device. A model deployed on rented cloud infrastructure remains remote processing even when the organization operates the server itself.

Local inference can give a team more control over its data path, but it does not automatically make an application private. Telemetry, external tools, cloud backups, retrieval systems, logs, and application analytics still need to be considered.

Gemma Hardware Requirements

Hardware requirements depend heavily on model size, precision, quantization, context length, and runtime. Google publishes approximate loading estimates for the current generation:

These are approximate model-loading estimates, not minimum system requirements. KV cache, long prompts, concurrent requests, multimodal processing, and training can require additional memory.

Quantization can reduce the footprint substantially. CPU inference is also possible with suitable runtimes, although practical performance depends on memory bandwidth, quantization, prompt size, and the response speed required by the application.

Fine-Tuning and Customization

Direct access to model weights gives developers several customization options. Google documents full-parameter tuning as well as parameter-efficient techniques such as LoRA, while QLoRA can combine adapter training with quantized weights.

Fine-tuning is not always necessary. Prompting may solve instruction or formatting problems, while retrieval-augmented generation may be a better fit when the goal is to supply changing or private knowledge.

A sensible workflow is to establish a baseline, identify the model’s actual failure mode, and then compare prompting, retrieval, adapters, or full fine-tuning. Adapted models should be reevaluated for task performance, safety, and regressions.

How Much Does Gemma Cost?

There is an important difference between the cost of obtaining a model and the cost of running it.

The current Gemma 4 generation is released under Apache License 2.0, which does not impose a license royalty under its conditions. Running the models can still involve hardware, cloud compute, storage, electricity, networking, monitoring, engineering, and evaluation costs.

Google also offers hosted options. As documented in Google Cloud pricing reviewed on October 18, 2026, its managed 26B endpoint was listed at $0.15 per 1 million input tokens, $0.60 per 1 million output tokens, and $0.015 per 1 million cache-hit tokens.

The Gemini Developer API pricing page reviewed on the same date also listed input, output, and context caching for the supported models as free on the Free Tier, while paid-tier model pricing was unavailable in the table reviewed.

Is Gemma Open Source?

The answer depends on which release is being discussed.

Google describes the family as open models, and Gemma 4 is released under Apache License 2.0. That license permits commercial use, modification, reproduction, and redistribution subject to its conditions.

But one license does not cover the entire historical family. Earlier models remain subject to separate Gemma Terms where applicable, while MedGemma uses separate Health AI Developer Foundations terms. Other specialized releases should be checked individually.

For the broader historical family, this review uses the more cautious term open-weight to avoid implying that every release has identical licensing conditions or that the complete family has been independently assessed against every definition of open-source AI.

Organizations planning commercial deployment should review the exact checkpoint license, required notices, distribution model, hosting terms, trademarks, applicable laws, and third-party rights.

Gemma Privacy

There is no single privacy policy that describes every way the models can be used.

With a genuinely self-hosted deployment, inference can remain on infrastructure controlled by the organization. The rest of the application still matters, including logs, telemetry, retrieval services, external tools, backups, and access controls.

For models accessed through the Gemini Developer API, the Google terms reviewed on October 18, 2026 distinguish between unpaid and paid services. Under the terms reviewed, content submitted through unpaid services may be used to improve Google products and may be reviewed by humans, while paid-service content is not used for product improvement, although limited abuse-monitoring logging can still apply.

Google Cloud has separate data-handling commitments for managed services. A third-party provider introduces another set of logging, retention, training-use, regional-processing, and security policies that must be assessed independently.

Security and Safety

Google documents safety training and evaluations and provides tools such as ShieldGemma and its Responsible Generative AI Toolkit. These measures do not remove the need for application-level security.

Tool-using systems should treat retrieved documents and external content as untrusted input, validate function names and arguments outside the model, and require appropriate authorization for consequential actions. Generated code should also be tested and reviewed rather than assumed safe because it compiles.

Self-hosted endpoints need authentication, network controls, quotas, and appropriate logging policies. Fine-tuning, quantization, or adding external tools can also change system behavior, so safety should be reevaluated after significant customization.

Gemma Benchmarks and Performance

Google reports higher scores for the current generation than its Gemma 3 27B non-thinking baseline across several benchmarks. In the Gemma 4 Technical Report, the 31B model scored 85.2 on MMLU Pro, 89.2 on AIME 2026 without tools, 80.0 on LiveCodeBench v6, and 84.3 on GPQA Diamond.

These are Google-reported results and were not reproduced by Aivonexi.

Independent results also require context. Artificial Analysis reported an Intelligence Index score of 39 for the 31B model in an April 2026 evaluation, compared with 42 for the Qwen model used in that test. Its October live comparison uses a different index presentation, and the displayed 26B A4B result was marked as estimated.

Benchmark results can change with the model version, evaluator, reasoning settings, prompt format, context, and test harness. For deployment decisions, testing the exact model against representative tasks is more useful than treating a leaderboard position as a universal measure of quality.

Gemma vs Gemini

Gemma and Google Gemini come from the same broader Google AI ecosystem, but they offer different levels of control and operational responsibility.

The open-weight family may be the stronger fit when downloadable weights, offline operation, custom infrastructure, local or edge deployment, or deeper model adaptation are requirements.

Gemini may be a better fit when a team wants managed inference and prefers Google to handle more of the underlying model-serving infrastructure. Which one produces better results still depends on the exact models and task being evaluated.

Gemma vs Other Open-Weight Models

Developers evaluating Google’s open-weight models are likely to compare them with other families such as Llama, Qwen, Mistral, DeepSeek, and Phi.

A practical comparison should consider the exact checkpoint, stored model size, active parameters, context-memory requirements, modalities, hardware fit, runtime maturity, licensing, fine-tuning support, and performance on the intended task.

The family’s appeal is not that it universally beats these alternatives. Its case rests on the combination of multiple model sizes, local and cloud deployment routes, multimodal support, customization options, and integration with a Google-backed developer ecosystem.

Gemma Pros and Cons

Who Should Use Gemma?

The family is particularly relevant to developers and AI application builders who need control over deployment, model selection, customization, or data flow.

Researchers may value accessible weights and the ability to work with a fixed checkpoint. Startups and technical teams may find these models useful when they have a measurable workload and the engineering resources to evaluate and operate them.

They can also be attractive to privacy-sensitive teams capable of controlling the complete application data path, as well as edge and mobile developers evaluating smaller or optimized artifacts.

Students and hobbyists interested in inference, quantization, fine-tuning, and local deployment may also find the models useful for hands-on experimentation.

Who Might Want Something Else?

Users looking for a finished assistant rather than a model-building platform may find a managed product such as Gemini, ChatGPT, or Claude simpler because it removes much of the model-serving work.

Teams already invested in Llama, Qwen, Mistral, DeepSeek, Phi, or another model ecosystem may also prefer to remain there unless Google’s models deliver a measurable advantage for their workload.

And not every problem needs a generative model. Search, deterministic extraction, speech recognition, or specialized classification may sometimes solve a task with less infrastructure and uncertainty.

Is Gemma Worth Using?

Gemma is worth evaluating when control over the model is part of the requirement, not merely an interesting extra.

The current generation combines several model sizes, multimodal inputs, 128K or 256K context windows, local deployment, cloud serving, quantization, and weight-level customization. Its Apache 2.0 license also differs materially from the separate Gemma Terms that apply to certain earlier releases.

The tradeoff is responsibility. Once a team operates its own model, hardware sizing, security, monitoring, runtime compatibility, evaluation, data handling, and updates become part of the system it must manage.

The useful question is therefore not whether this family is universally better than Gemini or another open-weight alternative. It is whether a specific checkpoint provides the right combination of quality, hardware fit, control, licensing, privacy architecture, and total operating cost for the application being built.

Last reviewed: October 18, 2026