Best local model for OpenClaw: gemma4 and gpt-oss:20b measured on four agent tasks

On a 128 GB M3 Max running OpenClaw 2026.9.7 with Ollama, gemma4 — the model OpenClaw's own Ollama setup suggests — passed all 12 graded runs across four agent tasks, and gpt-oss:20b passed 11 of 12 while making nearly three times as many failed tool calls. Both took a median of about 54 seconds per task. We ran each model three times on each task in a fresh workspace, graded the result by script, and recorded OpenClaw's own tool and token counts. Measured October 1, 2026.

For what OpenClaw itself costs and what a hosted model would cost instead, see OpenClaw pricing; for running a local model with an API fallback, multiple agents and models in OpenClaw.

What was run

The four tasks

Results

Times are wall-clock per run, including about five to seven seconds of OpenClaw start-up. "Tokens in" is uncached input as OpenClaw recorded it; the context it re-sent from cache is on top of that and is counted in the cost section below.

What the numbers say

• Both models are usable for short agent tasks. 23 of 24 runs passed, including the two-file fix, which needs reading several modules, editing two of them and rerunning tests.
• gemma4 used tools more cleanly. On the read task it made exactly one tool call every time; gpt-oss made three, two of which typically failed before it read the file. Over all twelve runs gpt-oss had 19 failed tool calls to gemma4's 7, and averaged 9.1 assistant turns per task to gemma4's 6.8.
• The one failure was gpt-oss on the count task: after thirteen tool calls it wrote a malformed counts.json and ended the turn without a reply.
• Speed is not the differentiator here. Median 53 s for gemma4 and 54 s for gpt-oss across all runs; the slowest single run was gemma4's 133 s on the two-file fix, with seventeen tool calls.
• The bigger model did not buy accuracy on these tasks. gpt-oss:20b is nearly three times gemma4's parameter count and twice its disk size.

Twelve runs per model is enough to see a pattern on these tasks and not enough to rank models generally. Long tasks, larger codebases and other quantizations were not tested.

The setup that mattered

• Native Ollama URL. OpenClaw's documentation says the /v1 OpenAI-compatible URL "breaks tool calling and models can emit raw tool-call JSON as plain text"; the runs used baseUrl without /v1 and api: "ollama".
• Pin contextWindow on hand-written entries. In a smoke run, an explicit model entry without it resolved to a 200,000-token context; OpenClaw's own Ollama setup writes 32,768 for local models, which is what these runs used.
• Ollama's context is separate. Ollama 0.35.0 loaded both models at 131,072 tokens regardless; that, not OpenClaw's budget, decides memory.
• Sandbox the shell. A local model running shell commands on your machine is the real risk here. With sandbox.mode: "all", exec ran in OpenClaw's Docker image with only the workspace mounted; the image is built once with the docker build command in OpenClaw's sandboxing docs.

// ~/.openclaw/openclaw.json — the runs used one model per config; the
// fallbacks line shows the pattern and was not part of the measured runs
{
  models: { providers: { ollama: {
    apiKey: "ollama-local",
    baseUrl: "http://127.0.0.1:11434",   // native Ollama URL — no /v1
    api: "ollama",
    timeoutSeconds: 600,
    models: [
      { id: "gemma4:latest", name: "gemma4:latest", contextWindow: 32768, maxTokens: 8192,
        params: { keep_alive: "30m" } },
      { id: "gpt-oss:20b",   name: "gpt-oss:20b",   contextWindow: 32768, maxTokens: 8192,
        params: { keep_alive: "30m" } },
    ],
  } } },
  agents: { defaults: {
    model: { primary: "ollama/gemma4:latest", fallbacks: ["ollama/gpt-oss:20b"] },
    sandbox: { mode: "all", workspaceAccess: "rw" },   // shell runs in Docker
  } },
  tools: { exec: { mode: "full" } },
}

What local costs

A local model swaps a per-token bill for time, disk and electricity. Per run, OpenClaw recorded about 16,415 uncached input tokens, 78,469 tokens of re-sent cached context and 1,142 output tokens for gemma4, and 13,761, 88,688 and 1,192 for gpt-oss. As rough arithmetic — tokenizers differ between models — the same counts at Claude Haiku 4.5's Kunavo rates ($0.70 in, $0.07 cached, $3.50 out per million) come to about $0.021 and $0.020 a run. Power was not measured; the electricity per run is watts × seconds ÷ 3,600,000 × your price per kWh.

The practical pattern is a local primary with a hosted fallback for the turns a local model fails. OpenClaw takes a fallbacks list per agent; a Kunavo key works as an OpenAI-compatible provider beside Ollama, billed per token from a prepaid balance. Nobody at Kunavo has run OpenClaw against its endpoint — these runs were entirely local.

FAQ

Run on October 1, 2026 on an Apple M3 Max (128 GB): OpenClaw 2026.9.7 (npm, Node 24.21.0), Ollama v0.35.0 (release binary), gemma4:latest and gpt-oss:20b pulled from the Ollama registry and checked by sha256. Each of 24 runs used a fresh workspace and fresh OpenClaw state, exec in OpenClaw's Docker sandbox, and a script grader; tool calls and token counts are OpenClaw's own JSON output. Task fixtures, graders and the adapter script are published with this page's evidence. Not measured: power draw, long tasks, other quantizations or smaller machines.