Open models give organizations control over model hosting, customization, and proprietary data that cannot leave their infrastructure.
2
Gemma 4 delivers high capability in smaller hardware footprints, from Pixel phones and laptops to single-GPU enterprise deployments.
3
The Apache 2.0 license lowers the legal and procurement barriers for sovereign institutions that want to adopt and adapt Gemma models.
Summary
Gus Martins and Ian Ballantyne explain why an organization might choose an open model even when a stronger hosted model is available. Gemma 4 is designed to run across a wide range of hardware, including phones, Macs, single GPUs, and small enterprise deployments. The E2B and E4B models keep their GPU memory needs near two and four billion parameters, while the 26B mixture-of-experts model activates about four billion parameters for its work. The speakers connect this efficiency to ownership: teams can keep private data on their own hardware, customize models, and avoid API and service dependencies. They also describe the move to Apache 2.0, which makes legal review easier for sovereign institutions. Ian closes with practical advice: test the models in existing workflows, build evaluations around your own tasks, and account for hosting, maintenance, energy, and hardware costs.
Open models fit situations where control matters more than maximum capability
Gus Martins distinguishes between Gemini and Gemma by where control lives. Gemini is Google's strongest model, but it runs on Google's servers and requires an API. An open model is useful when an organization needs to run on its own hardware, customize the model, or keep proprietary data inside its infrastructure. He says even the best proprietary model may not help directly in those situations. Gemma complements Gemini by providing access to model weights and more control over deployment. The argument is practical: model choice depends on data handling, infrastructure, and operational requirements, not only on which model is strongest.
Gemma 4 reduces memory requirements through effective parameter sizes
Gemma 4 includes E2B and E4B models aimed at phones, IoT devices, and other small hardware. The E2B model has around five billion parameters, but only about two billion need to occupy GPU memory. The remaining parameters are token mappings that can stay in other memory. The same idea applies to E4B. Both models accept text, vision, and audio input and produce text, with support for thinking, coding, and function calling. The larger 26B model is a mixture of experts. It has 26 billion parameters but uses space comparable to a four-billion-parameter model for the work it performs.
Smaller models can deliver strong quality with much less hardware
Gus says Gemma 4's 26B and 31B models rank fourth and seventh among open models on LM Arena at the time of the talk. He compares them with models that are at least twice or three times larger, and sometimes 20 times larger. The 31B dense model can run on one GPU, while competitors may require about 200 GB of memory, or four or five GPUs. He is clear that Gemma 4 is not the most intelligent model available. Its value comes from being strong enough for tasks such as email summarization, coding help, and agent workflows while costing less to run and requiring less hardware.
A permissive license makes sovereign adoption easier
Gus connects model ownership with sovereignty. An institution can adapt the model and avoid losing access because a provider changes service terms or stops allowing a use case. Google previously used a custom Gemma license. He says custom licenses can trigger long legal and procurement reviews, especially for sovereign institutions. Gemma 4 and future releases move to Apache 2.0, which makes it easier for legal departments to approve use. He gives examples from Ukraine, Bulgaria, and Brazil. Ukraine uses Gemma in parts of its services. Bulgaria built a Bulgarian-language national model based on Gemma 2, and Brazil has a Portuguese model based on Gemma 3.
Ownership changes the cost calculation for agent workloads
Ian Ballantyne says agentic tasks increase token generation costs because agents perform extended work rather than returning a single answer. Programming is among the high-token tasks shown in the State of AI report from OpenRouter. If a team already owns a laptop or GPU, running an open model locally can let it control that workload instead of paying for every generated token through a hosted service. Ian does not recommend using these models for a complete systems architecture redesign. He does recommend them for specific instructions such as refactoring, analysis, and generating small modular pieces of code. The right choice depends on capability, latency, and hardware cost.
Local deployment changes how teams think about device resources
Ian demonstrates a phone-based application that can accept images and interact with the surrounding world. The model chooses actions from defined skills, such as triggering calendar or maps applications, and Gemma 4 can reason about which function calls to make. Local execution replaces token charges with energy and device-utilization costs. A phone task may need an immediate response, or it may run offline as a background task when the phone is charging. On the enterprise side, Ian describes using a smaller model on one or two GPUs. A medical Gemma variant, MedGemma, could be deployed on one or two GPUs for a hospital's private data.
A local Mac can run parallel agents through LM Studio
Ian uses LM Studio on an M4 Mac with up to about 48 GB of unified memory. He loads the 26B model, which has four billion activated parameters, and starts an orchestrator that sends translation work to several subagents. Each window handles a different language, and the agents run in parallel on the local machine. The demonstration uses the Gemma 4 announcement as source material, then compiles the translations into a web page. Ian presents this as a pattern for processing files, performing analysis, or running other agent tasks without sending the work to a hosted endpoint.
Teams should evaluate local models on their own workflows
Ian recommends connecting an OpenAI-compatible interface to a local service such as Ollama or LM Studio, then changing only the model selection to try Gemma. The first test should use existing workflows, so a team can see what the model handles well, where tuning is needed, and which tasks exceed its ability. Generic benchmarks provide an indication of broad capability, but Ian says a model's value depends on performance on the team's own tasks. Teams must also budget for GPU hosting, uptime, maintenance, energy, device accelerators, RAM, and hardware purchases. Local ownership brings control, but it also creates operating responsibilities.
"The conversation becomes a little bit more complex but then there's a whole heap of things you can unlock like working offline or working on users private data that never leaves their device."19:22
Who should watch
You need to keep sensitive data on private infrastructure and are comparing hosted APIs with self-managed models.
Your team owns GPUs, Macs, or mobile hardware and wants to test agent, coding, translation, or offline workloads locally.
You are responsible for legal approval, procurement, or deployment costs for an open model in a government, medical, or enterprise setting.
