TL;DR: Ollama 0.32.0 (July 13, 2026) does two things that matter for home labs: it turns plain ollama into an interactive coding agent, and it ships Gemma 4 multi-token prediction that Ollama measures at ~90% faster on Apple Silicon. The speedup is the real news; the agent is a UX layer whose default backend is a cloud model, so privacy-focused users should read the fine print.

What you’ll get from this article:

• A plain-English explanation of what multi-token prediction (MTP) is and why it speeds up bandwidth-bound rigs — plus honest, labeled numbers for CUDA vs Apple Silicon.
• A walkthrough of the new interactive agent mode, including the one setting that decides whether your prompts stay local.
• A straight answer on whether the built-in agent replaces Open WebUI, and when it doesn’t.

Honest take: Update for the Gemma 4 speedup, not the agent. MTP is free performance on hardware you already own. The interactive agent is a convenient front door, but for a private home lab, Open WebUI still wins the moment you need multiple users, RAG, or a guarantee that nothing leaves the box.

What actually shipped in 0.32.0

Ollama published v0.32.0 on July 13, 2026. It is the current release as of this writing. The headline changes, straight from the release notes:

• Interactive agent experience. Running ollama with no arguments no longer drops you at a help screen. It launches an agent that can chat, write code, run a web search, and delegate work. The launch banner reads “Chat, Code, & Work (glm-5.2:cloud).”
• Gemma 4 gets multi-token prediction. Ollama reports Gemma 4 generating tokens “nearly 90% faster on average across a coding-agent benchmark” on Apple Silicon by using MTP. It auto-tunes how many tokens to draft, so it’s on by default, needs no configuration, and does not change the model’s output.
• Codex App integration renamed to ChatGPT. It’s now reachable via ollama launch chatgpt, with a --restore flag to get back to standard profiles.
• Streamlined launch menu. The launcher shows only the most popular integrations; the rest live behind ollama launch.
• Deprecation warnings for older agent models. Launching CodeLlama, Qwen2.5 (and Qwen2.5-coder), Llama 3.x, Mistral, StarCoder, or base DeepSeek-R1 now prints a warning before continuing.
• Qwen3.5 parser and renderer support was added on the engine side.

Nothing here breaks your existing ollama run <model> and ollama pull workflows. The API server (ollama serve) is unchanged, so anything you’ve wired up — Continue.dev, Open WebUI, a Cursor backend — keeps working exactly as before.

Multi-token prediction, explained without the math

Normal LLM inference is autoregressive: the model produces one token, feeds it back in, and produces the next. On a home-lab GPU, most of that time is spent moving the model’s weights from VRAM to the compute cores — the cores sit idle waiting on memory bandwidth. That’s why a bigger, faster GPU with the same bandwidth often doesn’t generate text much faster.

Multi-token prediction fixes the idle-cores problem. A small, fast “drafter” guesses several of the next tokens in the time the big model would spend on one. The full Gemma 4 model then verifies all of those guesses in a single forward pass. Consecutive correct guesses are accepted for free; the first wrong guess is replaced by the model’s own correct token, and the drafter resumes from there.

The analogy: instead of the expert writing one word, checking it, and writing the next, an intern drafts the next sentence and the expert proofreads the whole thing at once — keeping only the run of words that are right. Google’s own MTP drafters for Gemma 4 (released May 2026) claim up to ~3× faster inference without quality loss, because the full model always has the final say on every token.

That “without quality loss” part is the important bit. MTP is not quantization. You are not trading accuracy for speed — the output is bit-for-bit what the model would have produced anyway, just delivered faster. This is the same family of technique as speculative decoding in llama.cpp; Ollama has now baked a Gemma-4-specific version in and auto-tuned it so you don’t touch a config file.

What the speedup means for your hardware

Here’s where honesty matters, because the ~90% figure comes with a hardware asterisk.

Ollama measured that ~90% average speedup on Apple Silicon, where the MTP path runs through the MLX engine that Gemma 4’s drafters were optimized for first. If you own an Apple Mac Studio or a MacBook with an M4 Max, this is close to a free doubling of coding-agent throughput after a 10-minute update. That’s genuinely significant — Apple Silicon has always had the memory capacity for big models but lost the tokens/sec race to NVIDIA, and MTP narrows that gap.

On NVIDIA CUDA rigs, be more cautious. As of 0.32.0, Gemma 4’s MTP drafter is MLX-first, and the CUDA path is less mature. Expect a smaller gain — realistically in the single-digit to low-double-digit percent range, and model-dependent. Treat any specific CUDA MTP number as unverified until you benchmark your own box. The mechanism (idle-core reclamation) still applies, but the drafter and kernels aren’t as tuned for CUDA yet, and a bandwidth-saturated card has less idle compute to reclaim in the first place.

For a baseline to measure against, here are figures already verified on this site for Gemma 4 without MTP:

Setup	Gemma 4 variant	Baseline speed (no MTP)
RTX 4090 24GB	26B-A4B (MoE, Q4)	~149 tok/s
RTX 5090 32GB	7B–30B class, Q4	~140–198 tok/s
Mac M4 Max	70B-class, Q4	~28 tok/s

Sources: this site’s Gemma 4 QAT guide and Mac Studio M4 Max vs RTX 5090 comparison. MTP layers on top of these baselines — large on Apple Silicon, modest on CUDA.

The takeaway: run your own before-and-after. On a Mac, expect a big win. On a used RTX 3090 (~$1,070 in mid-2026) or an RTX 5090, expect a real but smaller bump — and don’t be surprised if a particular model shows almost none until the CUDA drafters catch up.

Which Gemma 4 to run for this

Gemma 4’s local lineup, with QAT (Quantization-Aware Training) sizes verified on this site:

• 12B — ~7 GB at Q4. Fits comfortably on an 8 GB card.
• 26B-A4B — the MoE variant, ~15 GB at Q4 thanks to QAT. Fits a 16 GB card like the RTX 5060 Ti 16GB. This is the sweet spot for MTP-accelerated coding agents because only ~4B parameters are active per token.
• 31B dense — ~18 GB at Q4, needs a 24 GB card.

There is no “Gemma 4 27B” — if you see that number floating around, it’s a misremembering of the 26B-A4B or the 31B. Pull with ollama pull gemma4 and pick the tag that fits your VRAM. For a full model-to-VRAM map, see best local AI models by VRAM.

The interactive agent: read the banner before you trust it

Now the part that needs a skeptical eye. When you type ollama and the agent launches, the banner says glm-5.2:cloud. That :cloud suffix is doing a lot of work: the default interactive agent is talking to a model hosted on Ollama’s cloud, not one running on your GPU.

For this site’s audience — people who run local AI specifically so their data stays on their own hardware — that is the headline caveat, not a footnote. Out of the box, the shiny new agent’s chat, code, and web-search features can route your prompts off-box. The web-search capability in particular has to reach the internet by definition; whether the query construction and results handling stay local or pass through Ollama’s servers is not something we could independently confirm at publish time, so assume it is not private until Ollama documents otherwise.

The fix is straightforward: point the agent at a local model. Run a local model directly the way you always have —

ollama run gemma4:26b

— and you get the fully local, MTP-accelerated experience with nothing leaving your machine. If you want the agent UI specifically, check ollama launch for the option to select a local backend rather than the cloud default. The rule of thumb: if the model tag ends in :cloud, it isn’t local. When in doubt, run a privacy audit on your setup using the checklist in our local AI privacy audit.

Does the built-in agent replace Open WebUI?

For a single user who mostly wants a terminal-based coding assistant, the built-in agent is genuinely convenient — one command, no separate service, no Docker. If that’s you and you’re pointing it at a local model, you may not need anything else.

But Open WebUI still wins the moment you need any of:

• Multiple users — accounts, logins, per-user history. The built-in agent is single-seat.
• RAG over your own documents — Open WebUI’s document pipelines and knowledge bases have no equivalent in the CLI agent.
• A polished web UI for non-technical family members, reachable from a phone or tablet.
• Model-agnostic pipelines and function calling that you configure once and reuse.

So it’s additive, not a replacement. Keep Open WebUI as your multi-user front end and household RAG box; use the built-in agent for quick, single-user coding sessions in the terminal. For a broader FOSS front-end comparison, aifoss.dev tracks the Open WebUI vs LibreChat vs built-in-agent landscape.

Should you update? A quick decision

• Apple Silicon, run Gemma 4: yes, update now. The MTP speedup is the single best free performance win of 2026 for your hardware.
• NVIDIA rig, run Gemma 4: yes, but benchmark before and after — the CUDA MTP gain is modest today and may need a point release to mature.
• You don’t run Gemma 4 at all: the update is still safe and worth taking for the Qwen3.5 support and general fixes, but the flagship feature won’t apply to you yet.
• You care most about privacy: update, but keep using explicit local model tags and don’t lean on the cloud-default agent. Nothing about your existing local workflow changes.

If a particular model still crawls after updating, the culprit is usually configuration, not the release — our guide on speeding up slow Ollama tokens/sec covers the usual offenders (partial GPU offload, context bloat, model reloading).

How to update

On macOS and Windows, use the built-in updater or download the current installer from ollama.com. On Linux:

curl -fsSL https://ollama.com/install.sh | sh
ollama --version   # should report 0.32.0

Existing models on disk are untouched — no re-download. After updating, confirm MTP is active on Gemma 4 by timing a generation:

ollama run gemma4:26b --verbose "Write a Python function to parse a CSV file."

The --verbose flag prints eval rate (tokens/sec) at the end. Compare that number to what you saw on 0.31.x. On Apple Silicon it should jump noticeably; on CUDA, note it and set expectations accordingly.

No GPU yet, or want to test at scale first?

If you’re deciding whether Gemma 4 with MTP is worth a hardware purchase, you can rent a GPU by the hour and benchmark the exact model-plus-quantization you’re considering before spending $1,000+. A few hours on a cloud RTX 4090 or 5090 through RunPod costs a few dollars and tells you your real tokens/sec — far cheaper than buying the wrong card. Our rent-vs-buy breakdown has the full math.

FAQ

Does multi-token prediction change the model’s answers? No. MTP is lossless — the full Gemma 4 model verifies every token, so the output is identical to running without MTP. You only gain speed.

Is the ~90% speedup real on my NVIDIA card? That figure is Ollama’s Apple Silicon measurement. On CUDA the gain is smaller today because the MTP drafters were MLX-optimized first. Benchmark your own rig with --verbose; don’t assume the headline number transfers.

Is the new ollama agent private? Not by default. Its default backend is glm-5.2:cloud, a cloud-hosted model. Run a local tag (e.g. ollama run gemma4:26b) for a fully local, private session.

Do I have to use the agent now that ollama launches it? No. ollama run <model>, ollama pull, and ollama serve all work exactly as before. The agent is only the no-argument default.

Why is Ollama warning me about my CodeLlama / Llama 3.x models? 0.32.0 marks several older families as deprecated agent models and warns before launching them. They still run — it’s a nudge to migrate to current models like Gemma 4, Qwen3.5, or Qwen3-Coder for better tool-use behavior.

Which Gemma 4 size should I run on 16 GB of VRAM? The 26B-A4B MoE variant at Q4 (~15 GB with QAT). It’s the best pairing for MTP-accelerated coding because only ~4B parameters are active per token.

Sources

1. Ollama v0.32.0 release notes — GitHub
2. Ollama releases index — GitHub
3. Speed-up Gemma 4 with Multi-Token Prediction — Google AI for Developers
4. Accelerating Gemma 4: faster inference with multi-token prediction drafters — Google Blog
5. Gemma 4 Multi-Token Prediction Delivers up to ~3x Faster Token Generation — InfoQ
6. Google AI Releases MTP Drafters for Gemma 4 — MarkTechPost
7. Ollama Release Notes July 2026 — Releasebot

Recommended Gear

Products mentioned in this guide, for readers pricing a build:

• Apple Mac Studio — largest MTP gains via the MLX engine; best capacity-per-watt for big models.
• MacBook Pro M4 Max — the portable Apple Silicon option that benefits most from Gemma 4 MTP.
• Used RTX 3090 24GB — still the tokens/sec value king (~$1,070 mid-2026); runs the 31B dense.
• RTX 5090 32GB — fastest single-card tokens/sec for the 7B–30B zone.
• RTX 5060 Ti 16GB — the budget 16GB card that fits the 26B-A4B MoE at Q4.

Hardware prices and tokens/sec figures are as of July 2026 and move with the market and with future point releases. Benchmark your own hardware before making a purchase decision.