TL;DR: Since Ollama v0.32.0 (July 11, 2026), typing ollama with no arguments launches a built-in interactive agent that chats, writes code, searches the web, and delegates tasks — zero extra software. But agent-mode web search routes through Ollama’s hosted API and wants an ollama.com sign-in, so it is not the fully-local experience the banner implies. Open WebUI still wins for multi-user, RAG, and airtight privacy.

	Ollama 0.32 agent	Open WebUI (v0.11)	ollama run (classic CLI)
Best for	Solo dev, quick questions in a terminal	Households, teams, RAG, browser/mobile access	Scripting, testing a model, air-gapped boxes
Setup cost	Zero — it’s the default binary behavior	One Docker command + a port	Zero
The catch	Web search and delegation call Ollama’s cloud API	Separate container to update and secure	No tools, no search, no memory — just a chat loop

Honest take: If you’re one person asking one-off coding questions, the built-in agent genuinely replaces a web UI now — run it signed out and it stays local. The moment you want documents, multiple users, or search that never touches a third-party API, Open WebUI plus SearXNG is still the answer.

For three years, the deal with Ollama was simple: it’s the engine, and you bring the interface — a terminal for quick tests, Open WebUI for everything else. Ollama v0.32.0 changed the deal. Run ollama with no subcommand and instead of the help text you get an interactive agent that announces it can “chat with models, code, search the web, and delegate real work.” That’s not a REPL. That’s a product — and it aims squarely at the reason most people install Open WebUI.

This review covers what the agent actually does, where the web-search traffic goes (the question that matters if you self-host for privacy), and an honest comparison against Open WebUI for the solo self-hoster it’s clearly built for. Tested against the v0.32 line; Ollama ships releases weekly, so check the release notes for what’s current.

What typing ollama does now

In v0.32.0 and later, the bare ollama command drops you into a full-screen terminal agent. Four capabilities, per the startup banner:

• Chat with any local model you’ve pulled, with conversation context kept across turns.
• Code: it can write files and run commands in your working directory, in the same genre as Claude Code or Gemini CLI, but pointed at your local models by default.
• Web search, so answers about current events stop being hallucinations.
• Delegation — hand it a multi-step task and it works through the steps rather than answering in one shot.

The old behavior is all still there. ollama run <model> gives you the classic bare chat loop, ollama serve, ollama pull, and the :11434 API are unchanged, and every downstream client — Open WebUI, Continue.dev, AnythingLLM — talks to v0.32 exactly as before. Nothing breaks; the agent is additive.

Two smaller changes in the same release matter for daily use. The integrations menu was streamlined, with the Codex App integration renamed to ChatGPT. And Ollama now shows deprecation warnings when you launch older models as agents — more on that below, because the list is longer than you’d expect.

The privacy question: where does web search actually go?

Here’s the part the release notes don’t put in bold. The agent’s web search is not a local crawler. It’s a hosted search API operated by Ollama — the same one announced on Ollama’s blog — with a free tier for individuals and higher limits attached to Ollama Cloud accounts. Using search from agent mode means signing in to an ollama.com account (or supplying an API key), and every search query leaves your machine for Ollama’s servers.

To be precise about the split, because it’s easy to get wrong in both directions:

• Model inference stays local when you’re using a local model tag. Your conversation with qwen3.6 on your own GPU does not transit Ollama’s infrastructure.
• Search queries do not stay local. The text of what you search for goes to Ollama’s hosted API, which performs the search and returns results the model then reads.
• Delegation to bigger models can pull in :cloud tags, which run entirely on Ollama’s servers — we covered how to detect and block those in our Ollama cloud models guide.

Is that a scandal? No — it’s how every consumer agent product works, and Ollama’s stated policy for its cloud services is transient processing without training on your data. But it moves the bare ollama command from “fully local by construction” to “local by configuration,” and self-hosters should make that configuration explicit. The reliable posture: stay signed out (ollama signout), so search and cloud delegation fail loudly instead of silently working via someone else’s servers. If you want to verify rather than trust, an outbound firewall rule on the Ollama binary — allow LAN, log WAN — will show you exactly what phones home during an agent session. Our Ollama security guide covers the firewall setup.

If you want web search and privacy, the self-hosted answer is unchanged: run SearXNG as your metasearch engine and wire it into Open WebUI’s search settings. That keeps queries on infrastructure you control, at the cost of the setup work the built-in agent lets you skip.

Agent mode vs. Open WebUI for the solo self-hoster

The real question the release poses: should a single-user homelab still bother with a web UI container? A working comparison, tested dimension by dimension:

Setup friction. The agent wins outright. It’s already installed — it is the binary you have. Open WebUI is one docker run plus a volume, which is easy but is also a container you now update, back up, and keep off the public internet.

Coding tasks. The agent wins for terminal-native work. It reads and edits files in your project directory, which Open WebUI fundamentally can’t do from a browser tab. For a persistent editor-integrated workflow you’d still reach for Continue.dev or Cline pointed at :11434 — see our Continue.dev + Ollama guide — but for “fix this script while I’m SSH’d in,” the agent is the shortest path there’s ever been.

RAG and documents. Open WebUI, decisively. Its document pipeline — uploads, embeddings, hybrid search, citations — has no equivalent in agent mode. If chatting with your own files is the use case, nothing changed; see our Open WebUI review.

Multi-user and remote access. Open WebUI, by definition. The agent lives in one terminal on one machine. Open WebUI serves a browser UI to your whole LAN (or tailnet) with per-user accounts and chat history.

Privacy control. Open WebUI plus SearXNG, as covered above. The agent’s search is convenient precisely because someone else runs it.

Model management. Even. Both sit on the same ollama pull layer; Open WebUI adds a GUI for it, the agent assumes you’re comfortable in a shell (you’re running Ollama — you are).

The verdict lands where the TL;DR said: the built-in agent now genuinely covers the solo, terminal-comfortable user who mostly asks coding and general questions — a real chunk of Open WebUI’s historical audience. It does not touch the multi-user, RAG, or hard-privacy cases.

The deprecation warnings, decoded

v0.32.0 warns you before launching certain older models in agent contexts: CodeLlama, Qwen2.5 and Qwen2.5-coder, Llama 3.x, Mistral (the older dense tags), StarCoder, and base DeepSeek-R1 all trigger it. The logic is tool calling. Agent mode leans on reliable structured tool calls — search this, run that, report back — and models from the 2023–2024 generation either lack tool-call training entirely or emit malformed calls often enough to wedge an agent loop. The warning is Ollama saying “this will disappoint you,” not “this is removed”; the tags still run fine for plain chat via ollama run.

For agent use, pick from the current tool-calling generation: Qwen3.6 (the 35B-A3B is the 24GB sweet spot), Gemma 4, Llama 4 Scout, or DeepSeek V4 distills. On hardware: a used RTX 3090 still carries the 24GB tier for exactly this class of model.

What about the Gemma 4 speed bump?

Coverage of the v0.32 era keeps bundling in the “Gemma 4 up to 90% faster” claim, so let’s place it accurately: multi-token prediction for Gemma 4 shipped in v0.31.1, late June 2026, not in 0.32 — and it lives in the MLX runner, which means Apple Silicon only. Gemma 4 ships with a small draft model; Ollama runs it alongside the main model, verifies its proposed tokens in a single pass, and auto-tunes the draft length, for roughly 90% faster generation measured on a coding-agent benchmark (Aider polyglot). It’s on by default with no configuration and doesn’t change outputs.

On a Mac Mini M4 Pro this makes Gemma 4 a legitimately snappy agent backend. On Linux/NVIDIA there is no equivalent MTP path in the GGUF runner as of the v0.32 line — CUDA users still get spec-decode options via llama.cpp directly, but not auto-enabled through Ollama. If a release changes that, it’ll be in the notes. Our sister site has the hardware-side numbers at runaihome.com.

And if you want to try agent workflows against models bigger than your VRAM without buying anything, a rented GPU on RunPod pointed at the same Ollama binary is the honest middle ground between local-only and handing prompts to a SaaS.

Upgrade path and post-upgrade checks

Upgrading is the standard flow: the desktop app self-updates, Linux re-runs the install script (curl -fsSL https://ollama.com/install.sh | sh), and package-manager installs update through the usual channel. After upgrading:

1. ollama -v — confirm you’re on a 0.32.x build.
2. ollama list — your pulled models carry over untouched.
3. Type ollama once to see the agent, then decide your posture: signed out for local-only, signed in if you’ve consciously accepted hosted search.
4. ollama ps during a generation — confirm the PROCESSOR column says GPU, and watch nvidia-smi (or sudo powermetrics on macOS) to be sure inference stayed on your silicon.

Verdict

Ollama 0.32’s agent is the biggest interface change the project has ever shipped, and it’s good — genuinely good — for the solo terminal user. It’s also the clearest signal yet of the direction we flagged in our Series B analysis: the convenient path now runs through Ollama’s account system and hosted APIs, and staying fully local is a choice you make, not the default you inherit. Make the choice deliberately: signed out, explicit local tags, firewall if you’re serious. Used that way, the agent is a real upgrade. Used on autopilot, it quietly un-self-hosts your search history.

For coding-focused agent workflows with cloud models in the mix, our sister site covers the tradeoffs at aicoderscope.com.

FAQ

Does Ollama 0.32’s web search work without an account? No. Agent-mode search uses Ollama’s hosted search API, which requires an ollama.com sign-in or API key. There’s a free tier for individuals (limits aren’t published — expect session and weekly caps). Signed out, search simply doesn’t run, which is exactly what a privacy-first setup wants: a loud failure instead of silent egress.

Did ollama run change in v0.32? No. ollama run <model> still gives the classic minimal chat loop, and serve, pull, and the OpenAI-compatible API on port 11434 are untouched. Every existing integration keeps working. Only the bare ollama command gained new behavior.

Is the 90% Gemma 4 speedup available on my NVIDIA card? No. Multi-token prediction for Gemma 4 landed in v0.31.1 inside the MLX runner, so it’s Apple Silicon only. Linux/NVIDIA inference through Ollama runs the GGUF path without auto-enabled MTP as of the v0.32 line.

Sources

• Ollama v0.32.0 release notes
• Ollama blog: Web search
• Ollama blog: Faster Gemma 4 on MLX with multi-token prediction
• AlternativeTo: Gemma 4 is now up to 90% faster on Apple Silicon in Ollama 0.31
• Ollama v0.31.1 release notes

Recommended Gear

• RTX 3090 — used 24GB workhorse for the Qwen3.6-35B-A3B class of tool-calling agent models
• Mac Mini M4 Pro — where Gemma 4’s MTP speedup actually applies; quiet always-on agent box