Open model guides age badly because the release cadence is monthly, not annual. Here is every dated Gemma 4 event in one place, so you can tell at a glance whether the version you are running is current.

• SEP 1, 2026Android Studio Quail 4 ships with local Gemma 4Bundled inference engine, native agentic tool calling, 23 curated Android skills, 12GB RAM minimum and 32GB or more recommended. Final stable release of the Quail cycle.
• AUG 20, 2026Gemma passes 1 billion downloadsOver 100,000 community variants published. Google also launched the Awesome Gemma GitHub repository as an official directory of community projects and tutorials.
• AUG 12, 2026Qwen3.8-Max open weights released (competitive context)2.4T parameters with about 95B active, text-only, roughly 4.89TB in BF16, under a custom license with revenue sharing rather than Apache 2.0.
• JUL 15, 2026Gemma 4 checkpoint refreshFlash Attention 4 on Hopper GPUs, tool-calling reliability fixes, new default vision configuration (280-token baseline bucket, 1120 maximum soft tokens), and chat template corrections. Re-pull required to benefit.
• JUN 3, 2026Gemma 4 12B Unified releasedThe fifth size. 11.95B parameters, unified multimodal architecture with no separate vision or audio encoders, 256K context, text plus image plus audio input.
• MAY 19-20, 2026Google I/O 2026Gemini 3.5 Flash, Gemini Spark, WebMCP browser agent standard, Managed Agents in the Gemini API, and open-weight models such as Gemma 4 added to Android Bench.
• APR 16, 2026Multi-Token Prediction drafters releasedMTP variants published for E2B, E4B, 26B A4B and 31B under Apache 2.0. Up to 3x faster inference through speculative decoding with no quality change.
• MAR 31, 2026Gemma 4 announcedInitial release in four sizes: E2B, E4B, 26B A4B MoE and 31B Dense, under Apache 2.0, with weights and documentation landing over the first days of April.

This is the most significant distribution moment Gemma 4 has had. Until now, running an open model as your coding assistant meant assembling the stack yourself: Ollama or llama.cpp, a quantized GGUF, an editor extension, and a fair amount of configuration patience. Quail 4 removes all of it. The engine is in the IDE, the model is Gemma 4, and it works with the network off.

Two details make it more than a novelty. First, native agentic tool calling: the assistant is not limited to autocompleting a line, it can plan and execute a refactor across files. Second, 23 curated skills shipped with the IDE, covering Android Gradle upgrades, profiling, navigation frameworks and adaptive UI design. Those skills are the difference between a general-purpose model guessing at Android conventions and a model being pointed at the right ones.

The practical framing from Google is blunt and worth repeating: your source code never leaves your local machine and you never hit token quota limits. For agencies, contractors and anyone under a client NDA, that removes an entire category of procurement conversation.

What you need to run it

Gemma 4 launched on March 31, 2026 in four sizes, with the fifth, the 12B Unified, added on June 3, 2026. The models come out of Gemini research and technology, but unlike Google's proprietary line they are published openly for anyone to download, modify, fine-tune and deploy.

The Apache 2.0 license is the part that changed the competitive picture. Developers and companies can use Gemma 4 commercially without negotiating anything. No monthly active user thresholds, no acceptable use annexes, no permissions to request. In August 2026, when Alibaba published the Qwen3.8-Max open weights under a custom license that includes a revenue-sharing requirement for large commercial users, the value of a plain Apache 2.0 grant became a line item rather than a philosophical preference.

Architecturally the family is not one design scaled up and down. The E2B and E4B use Per-Layer Embeddings to get the representational depth of a much larger model at a fraction of the resident memory. The 26B A4B is a Mixture of Experts model with 128 small experts, activating 8 per token plus one shared expert. The 12B Unified drops separate vision and audio encoders entirely and projects image patches and audio spectrograms straight into the transformer's embedding space. The 31B is a straightforward dense model where all 30.7B parameters fire on every token.

One specification that gets overlooked: the training data knowledge cutoff is January 2025. Gemma 4 is a strong reasoner over information you give it, not a current-events oracle. Plan for retrieval, tool calls or MCP connected sources in any deployment where recency matters.

Google built Gemma 4 to span phones, laptops, consumer GPUs and production servers. Each size has a distinct deployment sweet spot, and the modality differences between them matter more than the parameter counts.

How to choose in one paragraph

If you have a single consumer GPU and no audio requirement, take the 26B A4B. If you need audio or you are on a 12GB to 16GB card or an Apple Silicon laptop, take the 12B Unified. If the target is a phone or an embedded board, take E2B. If it is a laptop app that must run without a GPU, take E4B. Take the 31B only when you have 20GB or more of VRAM and the last few benchmark points genuinely change the outcome, because it costs roughly eight times the compute per inference step of the 26B for a small quality gain.

A modality trap worth flagging: it is easy to assume the biggest model does everything. It does not. The 31B and 26B accept text and image only. Audio input lives on E2B, E4B and the 12B Unified. If your product transcribes or reasons over speech, your ceiling is the 12B, not the 31B.

Gemma 4 combines multi-step reasoning, structured output, multimodal input and long context. The July 15 refresh sharpened three of those specifically, so the capability picture in September 2026 is not the one from launch day.

How to read this table

Reasoning degrades gracefully, competitive coding does not. Look across the GPQA Diamond row: 84.3, 82.3, 78.8. You lose about six points going from the 31B all the way down to the 12B. Now look at Codeforces ELO: 2150, 1718, 1659, 940, 633. Competitive programming ability falls off a cliff. If your workload is contest-style algorithmic code, size matters enormously. If it is reasoning over documents, it barely does.

The 26B A4B is the value pick and it is not close. It trails the 31B by 2.6 points on MMLU Pro, 0.9 on AIME 2026 and 2.0 on GPQA Diamond, while activating 3.8B parameters per token instead of 30.7B. For anything that is not a coding contest, the quality difference is inside the noise of your own prompt engineering.

Do not dismiss the small models on these numbers. E2B scoring 60.0% on MMLU Pro sounds modest until you remember it runs in about 1.5GB of RAM on a phone, offline, with audio input. It is not competing with the 31B. It is competing with having no model at all in that context.

Generation speed: with MTP drafters enabled, dense models see roughly 2x to 3x faster generation, while the 26B MoE gains less because the architecture already reduces per-token compute. On Apple Silicon, Ollama's auto-tuned MTP roughly doubles throughput on real coding-agent workloads. Speed figures move with tooling releases, so treat any specific tokens-per-second number, including ours, as a snapshot rather than a specification.

The honest verdict

Beyond these four, teams are also evaluating Mistral for European data sovereignty, DeepSeek for cost-efficient Chinese-language work, and Microsoft's Phi family for ultra-lightweight edge scenarios, alongside proprietary options from Anthropic and OpenAI. None of them currently combine Gemma 4's span of hardware coverage, multimodal input, official inference acceleration and unrestricted licensing in one family.

The pattern across all of these is the same: they are places where an API call was either impossible, too expensive at volume, or unacceptable on privacy grounds. That is the honest use case for open weights, and it is a large one.

Agents fail on reliability, not intelligence. A model that produces a correct answer 95% of the time and a malformed JSON tool call the other 5% is unusable in a ten-step workflow, because compounding failure takes you to roughly a 60% success rate. This is why Google's July patches, which targeted systematic JSON errors and parameter accuracy rather than raw reasoning, are the most consequential Gemma 4 update of the year for anyone building agents.

The second half is latency. In an agent loop, every tool result is appended and the whole context is re-processed. Prefill, not generation, becomes the dominant cost. Flash Attention 4 on Hopper GPUs delivers 25% to 70% higher prefill throughput and up to 31% faster time to first token, and that translates directly into agent loops that feel responsive instead of sluggish.

Standards support: Gemma 4 works with Anthropic's Model Context Protocol, the de facto standard for connecting models to external tools and data. Google extended the same idea into the browser with WebMCP, proposed at I/O 2026, which lets browser-based agents call JavaScript functions and interact with HTML forms through a standard interface, with an origin trial beginning in Chrome 149. Any model with function calling can participate, and Gemma 4's advantage is that it can do so locally, with no per-call cost and no data leaving your infrastructure.

Android Studio Quail 4 is the clearest working example of this stack: an agentic model, a curated skill set, tool calling and a local runtime, executing multi-file refactors with the network disconnected.

Cloud coding assistants are excellent and they all share one property: your code, your prompts and your context leave your machine. For a solo developer on a side project that is a non-issue. For an agency under client NDA, a bank, a hospital or anyone with a data residency clause in their contract, it is the whole conversation.

Gemma 4 makes the local alternative credible rather than merely possible. Code is also the ideal workload for speculative decoding, because closing brackets, repeated identifiers and boilerplate are exactly what a small drafter predicts well, so MTP delivers its largest gains here. Ollama's auto-tuned MTP on Apple Silicon roughly doubles generation speed on coding-agent benchmarks without changing a single output token.

Practical setups, in ascending order of effort: Android Studio Quail 4 if you are building Android, since it is already installed. LM Studio for a chat interface plus an OpenAI-compatible local API. Continue.dev pointed at a local Ollama endpoint for in-editor completion in VS Code or JetBrains. llama.cpp with an MTP drafter when you want maximum throughput and are willing to tune flags.

One expectation to set honestly: on hard, novel algorithmic problems a frontier cloud model is still ahead. What a local Gemma 4 gives you is a strong assistant for the 90% of work that is refactoring, boilerplate, test writing, translation between frameworks and explaining unfamiliar code, at zero marginal cost and zero data exposure.

Step 1: Install with Ollama (easiest method)

# Install Ollama (macOS / Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Run the default 26B A4B MoE model (recommended for most developers)
ollama run gemma4

# Or choose a specific Gemma 4 size:
ollama run gemma4:e2b   # Edge: phones, Raspberry Pi (~1.5GB)
ollama run gemma4:e4b   # Edge: laptops, mobile apps (~5GB)
ollama run gemma4:12b   # Unified multimodal with audio (~8GB Q4)
ollama run gemma4:26b   # MoE: best speed/quality balance (~14-18GB)
ollama run gemma4:31b   # Dense: maximum quality (~20GB)

Step 2: Refresh weights pulled before July 15, 2026

# The July 15 build adds Flash Attention 4, tool-calling fixes,
# a new vision config and chat template corrections.
# Model names did not change, so nothing warns you.

ollama pull gemma4
ollama pull gemma4:12b

# Hugging Face users: re-download from the google/gemma-4 collection.

Step 3: Visual interface with LM Studio

If you prefer a GUI, LM Studio offers one-click download and chat for all Gemma 4 variants. Download it from lmstudio.ai, search for Gemma 4 in the model browser, choose your size and quantization, and start chatting. LM Studio also exposes a local OpenAI-compatible API server, which is the simplest way to point an existing application at a local model without changing your code.

Step 4 (advanced): maximum control with llama.cpp and MTP

# Build llama.cpp with GPU support
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j

# Run the Gemma 4 26B A4B MoE model
./llama.cpp/llama-cli \
  -hf unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL \
  --temp 1.0 --top-p 0.95 --top-k 64

# For 2-3x speed on dense models, add the MTP assistant drafter:
# download both the base GGUF and its -assistant GGUF, then serve with
#   --model-draft  --spec-type draft-mtp --spec-draft-n-max 4
# Tip: QAT checkpoints preserve the MTP speedup when quantized.
# Note: MTP helps dense models most (12B/31B); the 26B MoE gains less.

Step 5: Python developers, Hugging Face Transformers

pip install transformers torch
# Load with model ID: google/gemma-4-31B-it
# MTP drafters ship under the matching -assistant repositories,
# released April 16, 2026 under the same Apache 2.0 license.

Try it without installing anything

Explore the larger Gemma 4 models in Google AI Studio. For on-device variants, see Google's AI Edge resources. Android developers get it built in with Android Studio Quail 4.

Where to download Gemma 4 model weights

Yes. E2B and E4B were built for on-device use and run offline on smartphones, Raspberry Pi boards and embedded hardware such as NVIDIA Jetson. At 4-bit, E2B fits in roughly 1.5 GB of RAM and E4B in about 5 GB. The 12B Unified extends the same multimodal capability to laptops and mid-range GPUs at around 8 GB quantized.

E2B, E4B and the 12B Unified all accept native audio input, which neither Llama 4 nor the open Qwen weights offer at these footprints. That combination, small enough for a phone and able to hear, is what makes deployments like Aarogya Setu 2.0 possible: an app with over 100 million Android downloads running an open model on the handset itself.

The agentic angle makes on-device more interesting than it was a year ago. A warehouse scanner running E2B can read a barcode, check inventory through an MCP tool call over the local network and trigger a reorder, with no cloud round trip in the loop and nothing sensitive leaving the building.

Apache 2.0 allows unrestricted fine-tuning on proprietary data, with no permission request and no obligation to publish the result. Using QLoRA through tools such as Unsloth, the 31B can be fine-tuned with as little as 16 GB of VRAM, which a single RTX 4090 provides. Full fine-tuning of all parameters needs roughly 80 GB.

Supported paths include Google Colab, Vertex AI, Hugging Face TRL, Unsloth and consumer GPUs. For most domain adaptation work QLoRA is sufficient, and it is dramatically cheaper to iterate on.

The most common fine-tuning objective in 2026 is not knowledge injection, it is reliability: training the model to call the right tools with correctly typed parameters, return schema-valid JSON every time, and follow a specific multi-step workflow without improvising. Google's July tool-calling patches raised the baseline, but a domain-specific fine-tune on your own tool schemas still buys a meaningful reduction in retry rate.

A practical note on size selection for fine-tuning: teams frequently fine-tune the 12B or the 26B rather than the 31B, because the smaller starting point trains faster, serves cheaper and, after adaptation to a narrow domain, often closes most of the gap to the larger base model on that domain.

1. The knowledge cutoff is January 2025

Gemma 4 knows nothing about events after January 2025 and will answer confidently about them anyway. Any deployment touching current information needs retrieval augmented generation, live tool calls or MCP connected data sources. This is not a defect, it is a property of every static model, but it catches teams who benchmark on reasoning tasks and then deploy on current-events questions.

2. The two largest models cannot hear

The 26B A4B and 31B Dense accept text and image only. If your product needs audio, your quality ceiling is the 12B Unified, not the 31B. Discover this during architecture, not during integration.

3. Context tops out at 256K

Generous for most work, and well short of Llama 4 Scout's 10M. If your use case genuinely requires ingesting an entire large repository or a corpus of long documents in a single pass, Gemma 4 is the wrong tool and chunking with retrieval is the workaround.

4. Self-hosting has an operational cost

Zero API billing is not zero cost. Someone maintains the serving stack, monitors GPU utilisation, handles quantization trade-offs, manages weight updates like the July refresh, and gets paged when throughput degrades. At small volume, a cloud API is often cheaper all-in. The economics turn in favour of self-hosting at sustained volume, or immediately when privacy is non-negotiable.

5. Frontier cloud models are still ahead at the top end

On the hardest novel reasoning and coding problems, Gemini 3.7 Flash and its peers remain ahead of any open model you can run on a workstation. The honest question is not which is better in the abstract, it is whether the gap matters for your specific workload. For a great deal of production work, it does not.

6. Language support is uneven

Pretraining spans 140+ languages but validated out-of-the-box quality is documented for 35 or more. Performance in the long tail varies. Benchmark your target languages rather than assuming coverage equals quality.

Every specification, benchmark score and date on this page was checked against a primary source in September 2026. Where a figure comes from community testing rather than Google, it is labelled as directional in the text. If you find a number here that has since changed, the changelog above is the first thing we update.

What is Gemma 4?

Gemma 4 is Google DeepMind's most capable family of open AI models, announced March 31, 2026 under Apache 2.0. It ships in five sizes: E2B, E4B, 12B Unified, 26B A4B MoE and 31B Dense. All five take image input, three take audio, and context runs to 256K tokens on the three larger sizes.

How many downloads does Gemma have?

Google announced on August 20, 2026 that Gemma has passed 1 billion downloads, with more than 100,000 community variants published. That is roughly double the 500 million figure reported around the Gemma 4 launch in March 2026.

Is Gemma 4 built into Android Studio?

Yes. Android Studio Quail 4, released September 1, 2026, bundles an inference engine that runs Gemma 4 locally. It needs 12GB of RAM minimum, 32GB or more recommended. Native agentic tool calling lets it run multi-step refactors offline, so source code never leaves the machine and there are no token quotas. It ships with 23 curated Android skills.

What changed in the July 2026 Gemma 4 refresh?

On July 15, 2026 Google refreshed the checkpoints with four changes: Flash Attention 4 for NVIDIA Hopper GPUs (25% to 70% higher prefill throughput, up to 31% faster time to first token), tool-calling reliability fixes (Tau2 Telecom up about 10.1%, TB2 up about 4.5% on the 31B), a new default vision configuration using a 280-token baseline bucket and 1120 maximum soft tokens for sharper OCR, and chat template corrections. Model names did not change, so re-pull your weights if they predate that date.

What are the Gemma 4 benchmark scores for every model size?

Instruction-tuned, from the official model card. MMLU Pro: 31B 85.2%, 26B 82.6%, 12B 77.2%, E4B 69.4%, E2B 60.0%. AIME 2026: 89.2%, 88.3%, 77.5%, 42.5%, 37.5%. GPQA Diamond: 84.3%, 82.3%, 78.8%, 58.6%, 43.4%. LiveCodeBench v6: 80.0%, 77.1%, 72.0%, 52.0%, 44.0%. Codeforces ELO: 2150, 1718, 1659, 940, 633. MMMU Pro vision: 76.9%, 73.8%, 69.1%, 52.6%, 44.2%.

What is Gemma 4 12B Unified?

The fifth Gemma 4 size, released June 3, 2026. It has 11.95B parameters and a unified multimodal architecture with no separate vision or audio encoders: image patches and audio spectrograms pass through lightweight projection layers instead. It takes text, image and audio, supports 256K context, and runs in about 16GB VRAM at full precision or 8GB quantized. It scores 77.2% on MMLU Pro and 78.8% on GPQA Diamond.

What is Gemma 4 MTP (Multi-Token Prediction)?

Lightweight companion drafter models released April 16, 2026 for E2B, E4B, 26B A4B and 31B. They use speculative decoding for up to 3x faster inference with identical output: the drafter proposes several tokens and the main model verifies them in one parallel pass, sharing the target's KV cache. Supported in llama.cpp, Ollama, Hugging Face Transformers, vLLM and MLX, under Apache 2.0.

Is Gemma 4 free to use commercially?

Yes. Apache 2.0 allows unlimited commercial use, modification, fine-tuning and redistribution, with no royalties and no monthly active user cap. As of September 2026 that is more permissive than Llama 4 (700M MAU restriction) and than Qwen3.8-Max, whose August 2026 open weights carry a custom license with a revenue-sharing requirement for large commercial users.

What are the Gemma 4 model sizes?

E2B: 2.3B effective parameters (5.1B with embeddings), about 1.5GB at Q4. E4B: 4.5B effective (8B with embeddings), about 5GB. 12B Unified: 11.95B, about 8GB. 26B A4B MoE: 3.8B active of 25.2B total, 14GB to 18GB. 31B Dense: 30.7B all active, about 20GB.

How do I download and run Gemma 4 locally?

Install Ollama from ollama.com and run ollama run gemma4 for the 26B A4B, or gemma4:12b for the Unified model. Weights are also on Hugging Face, Kaggle and NVIDIA NIM. Android developers can use the copy bundled with Android Studio Quail 4.

What hardware do I need to run Gemma 4?

E2B about 1.5GB at Q4 (smartphones, Raspberry Pi). E4B about 5GB (laptops). 12B Unified about 8GB quantized or 16GB full precision (RTX 4070 class, Apple Silicon). 26B A4B 14GB to 18GB at Q4 (single RTX 3090 or 4090, or a 24GB Mac). 31B about 20GB at Q4. Android Studio's bundled engine asks for 12GB system RAM minimum, 32GB or more recommended. All sizes run on CPU, more slowly.

How does Gemma 4 compare to Qwen 3.8?

They target different tiers now. Qwen3.8-Max open weights (August 12, 2026) are 2.4T parameters with about 95B active, roughly 4.89TB in BF16, text-only, and realistically need GB300 class or heavily quantized multi-GPU serving. The license moved away from Apache 2.0 and adds revenue sharing for large commercial users. Gemma 4 is the family you can run on a phone, laptop, single GPU or workstation, with image input everywhere and audio on three sizes, under clean Apache 2.0 terms. At the 27B tier, Qwen 3.6 remains a strong text-only local coding choice.

How does Gemma 4 compare to Llama 4?

Gemma 4 31B beats Llama 4 Scout (109B total) on reasoning, including GPQA Diamond at 84.3% against roughly 74.3%. Gemma 4 is Apache 2.0 with no caps while Llama 4 has a 700M MAU restriction, and Gemma 4 covers edge deployment where Llama 4 has no small model. Llama 4 Scout leads on context window at 10M tokens.

Can Gemma 4 run on a smartphone?

Yes. E2B fits in roughly 1.5GB RAM at Q4, runs on modern Android phones through Google AICore, works fully offline, accepts native audio and handles 128K context. India's National Health Authority integrated Gemma 4 into Aarogya Setu 2.0, an Android app with more than 100 million downloads.

What is the Gemma 4 context window?

128K tokens on E2B and E4B. 256K tokens on the 12B Unified, 26B A4B MoE and 31B Dense.

Does Gemma 4 support images, video and audio?

All five sizes accept text and image at variable resolution. E2B, E4B and the 12B Unified also accept native audio; the 26B and 31B do not. Video is handled through frame sequences. Since July 15, 2026 the default vision configuration uses a 280-token baseline bucket and 1120 maximum soft tokens, supporting roughly 2.51 megapixel inputs.

What is the Gemma 4 knowledge cutoff?

January 2025, per the official model card. For anything more recent, pair Gemma 4 with retrieval augmented generation, live tool calls or MCP connected data sources.

How many languages does Gemma 4 support?

Pretrained on more than 140 languages, with documented out-of-the-box support for 35 or more. Treat 140+ as coverage and 35+ as the validated tier, and benchmark your own target languages before production.

Can Gemma 4 be fine-tuned?

Yes, with no license restriction. QLoRA through Unsloth fine-tunes the 31B with as little as 16GB VRAM. Full fine-tuning needs roughly 80GB. Supported on Google Colab, Vertex AI, Hugging Face TRL and consumer GPUs.

Can Gemma 4 be used for agentic AI workflows?

Yes, and this is where it improved most in 2026. Native function calling, JSON structured output, system instructions and configurable thinking modes, plus July's tool-calling reliability patches and Flash Attention 4 prefill gains that matter when every agent turn re-reads a long tool schema. Compatible with Anthropic's MCP and Google's WebMCP.

Which Gemma 4 model should I use?

Most developers: the 26B A4B MoE. Phones and IoT: E2B. Laptops: E4B. Multimodal work including audio on a 12GB to 16GB GPU or Apple Silicon: the 12B Unified. Maximum quality with 20GB or more VRAM: 31B Dense. Android development: the copy inside Android Studio Quail 4.

What is the difference between Gemma 4 and Gemini?

Gemini is Google's proprietary cloud family, accessed by API and iterating fast: Gemini 3.7 Flash shipped in August 2026 alongside Gemini 3.5 Transcribe and Gemini Omni 1.1 Flash. Gemma 4 is the open-weight family built from the same research, designed to run on your own hardware under Apache 2.0. Gemini gives you frontier capability as a service; Gemma 4 gives you ownership, offline operation and full data privacy.

What is the best open source AI model in September 2026?

It depends on your hardware. For anything running on a phone, laptop, single consumer GPU or workstation, Gemma 4 is the strongest all-round family. For text-only local coding at the 27B tier, Qwen 3.6 remains a community favourite. For ultra-long context, Llama 4 Scout leads at 10M tokens under Meta's license. For data-centre scale open weights, Qwen3.8-Max is the largest available, though text-only and licensed with revenue sharing.

Six months after launch, the interesting thing about Gemma 4 is not any single benchmark. It is that the family kept shipping while everyone was watching the cloud models. A fifth size in June. A quiet checkpoint refresh in July that made tool calling meaningfully more reliable. A billion downloads in August. A first-party IDE bundling it in September. That is a maintained platform, not a launch event.

The strategic picture also clarified. When Qwen's flagship open weights moved to a custom license with revenue sharing, and Llama kept its user cap, Gemma 4 became the only major family combining unrestricted Apache 2.0 terms, hardware coverage from phone to workstation, image input on every size and audio on three. If you are choosing an open model to build a product on rather than to benchmark, that combination is the reason to pick it.

Be clear-eyed about the limits: a January 2025 knowledge cutoff, no audio on the two largest sizes, 256K of context rather than millions, and an operational cost to self-hosting that a spreadsheet comparing token prices will not show you. Those are planning constraints, not deal breakers, and knowing them upfront is what separates a deployment from a demo.

At Auriga IT, we help businesses turn model releases into working systems: choosing the right size for the hardware you have, wiring open models into real applications, and running them on infrastructure that holds up.