Which model is your main Claw's brain? 🧠

We’ve got a whole lot of different models to choose from these days, and I’m curious what everyone’s actually running under the hood.

What’s powering your main Claw?

Are you running GPT, Claude, Gemini, something local, or have you found a model that the rest of us are sleeping on?

More importantly, why that one?

Is it the reasoning? Speed? Cost? Personality? Tool use? Or have you just found something that works so well you haven’t bothered changing it?

I’m particularly curious about folks who’ve experimented with a few different models before settling on their daily driver. And for those of you running multiple Claws, do you give them different brains for different jobs?

Tell us what you’re running, what you’ve tried, and what keeps bringing you back to your favorite. I’m betting we’ll uncover a few interesting combinations none of us have considered yet. :lobster:

-Joe

sol 6.1 medium. Because it is the one that use every day on Codex. I am not connected my Claude subscription yet… The last thing that I read months ago was that Anthropic bans openclaw. Has that changed? Can I connect the subscription? I used both normally

this my seup in codex… I need to move it to openclaw

1 Like

The main is Deepseek v4 Pro and Deepseek 4.1.
v4 Pro is pleasant to talk to. 4.1 is capable and cheap. So Pro is my main to talk to, and 4.1 is worker and subagent.

2 Likes

Deepseek v4.1 Flash via Opencode Go is my default. I think it’s just an all-around solid contender, use it for most work and day to day agentic tasks.

2 Likes

Opus 5.5 everything! It’s just that good. Well, we do delegate some busy work to Sonnet subs. Fallback (mostly for safeguard reasons) is Mistral 4 Large.

1 Like

I was using Minimax, but they decided to force me to move to their new Subscription and I did not want that, so I moved to z.ai… I am using mostly glm 5.3 flash, and 5.3 for more complex work.
I also have kokoro for local tts, local emebdding model, local Qwen3‑Coder 30B
MoE coder; fits at Q5 (~21.4GB).
Excellent for agentic coding workflows.

I also play around with the local models
Video LTX and WAN

music MiniMax Music 3

1 Like

Hi @joe . Old geek, first time posting. I’ve been relying on other External AI’s for most of my info, but I think I am needing some human input. I’m running the latest version of openclaw (I think, it’s a 2 day old install) on a NVidia DGX Spark. First day I used Nemotron (the latest), and had several other models left over from before… exceeded all RAM and things got real pokey. Had claude redo the config, and it recommended gemma4:12b, lots of free RAM (using 6G out of 130G) but now that we’re digging into doing things I’m seeing issues again. output tokens exceeded, compaction needed, etc. I think I have a 128K context window. Anyway, short ask - 1) What model should I use? 2) Where do I go to make basic changes in openclaw? I’ve seen things in WebUI that I can’t seem to find in OpenClaw.

majorpeabody

Telling me to “go look over there” is an acceptable answer

Sonnet 5.5 it does the job for most things scripts and it’s not that expensive. Opus 5.5 for very difficult tasks that Sonnet fails at. I also have multiple free back up models.

2 Likes

Hey there @MajorPeabody, and welcome aboard! Always glad to see another old geek turn up around here. :slight_smile:

First off, you’ve got a pretty substantial piece of hardware in that DGX Spark. I suspect we can get considerably more out of it than what you’re currently seeing.

On the model question: I’d give Qwen3.6 35B A3B a look. NVIDIA actually recommends an optimized version of it running through vLLM for OpenClaw on the DGX Spark. They’ve even put together a walkthrough specifically for this combination: NVIDIA’s OpenClaw / DGX Spark Guide (this is me saying ‘go look over there’ at least once, but there’s stuff worth lookin’ at).

Gemma 4 12B is comparatively lightweight for your hardware. It’s perfectly reasonable for smaller tasks, but I think you’ll find a larger, agent-oriented model considerably more capable when OpenClaw starts juggling tools, instructions, and multiple steps. I’d also make sure you don’t have several large models loaded simultaneously, since that may explain your earlier memory problems.

On the token and compaction issues: Those aren’t necessarily indications that you’ve picked the wrong model. A model advertising a 128K context window doesn’t automatically mean your inference server is actually allocating that much context. OpenClaw’s configured context window, the inference server’s actual context allocation, and the model’s output-token limit are related but different settings.

I’d check those before changing anything else. NVIDIA recommends at least 32K context for OpenClaw, preferably 64K or more if you’ve got the memory available. Compaction itself is normal as conversations grow, but if you’re running into it almost immediately, something deserves a closer look.

On where to change things: You’ve got a few options.

  • OpenClaw Control UI: Look under Settings → Models for model selection, and the Config section for broader configuration.

  • Terminal: Run openclaw configure for the guided configuration wizard.

  • Configuration file: ~/.openclaw/openclaw.json is where the main configuration lives.

  • Diagnostics: openclaw models status and openclaw config validate are useful starting points.

One distinction worth mentioning: if you’re referring to Open WebUI, that’s separate from OpenClaw’s Control UI. Some model-serving settings need to be changed in Ollama or vLLM rather than in OpenClaw itself.

Here’s the OpenClaw configuration documentation for reference. (Omg I did it again!)

Happy to help you get this sorted!

-Joe

1 Like

@MajorPeabody The compaction is most likely OpenClaw’s own budget, not the model. Per docs/providers/ollama/advanced.md (2026.10.9), auto-discovered Ollama models get contextTokens capped at 32,768, and OpenClaw sends that to Ollama as num_ctx on each request. So gemma4 runs in 32K whatever it advertises, and the system prompt and tool schemas use a good part of that before you type anything.

Two checks:

  • /context detail in a chat shows the system prompt size and the size of each tool schema.
  • ollama ps on the Spark has a CONTEXT column. That is what Ollama actually allocated.

To get more, write the model entry yourself. This is our live entry (Ollama on a 96 GB box, port changed to the default):

models: { providers: { ollama: {
  baseUrl: "http://127.0.0.1:11434",
  api: "ollama",
  timeoutSeconds: 600,
  models: [{
    id: "qwen3.8:27b-mlx",
    reasoning: true,
    input: ["text", "image"],
    contextWindow: 131072,  // what the model supports
    contextTokens: 98304,   // OpenClaw's input budget
    maxTokens: 8192,        // output cap
    params: { num_ctx: 131072, keep_alive: "30m" },
    compat: { supportsTools: true },
  }],
}}}

params.num_ctx wins over contextTokens for what Ollama allocates (same doc). Prompt and output share that window, so we keep num_ctx at or above contextTokens + maxTokens (106,496 here).

On the RAM: keep one big model loaded at a time. On our 96 GB box, Nemotron 3.5 Super alone took about 68 GB, and with it loaded the other models loaded slowly or not at all. OLLAMA_MAX_LOADED_MODELS=1 stops that pile-up, but then every switch evicts the agent’s model and the next turn rereads the whole prompt. We measured that on a 27B model on a 64 GB Mac: a cold 33,772-token system prompt took 167 s, the warm repeat 0.5 s. That is why keep_alive is set.

If you take joe’s vLLM route: we ran vLLM on a DGX Spark for about four weeks. Our first service was the same Qwen3.6-35B-A3B, NVFP4 weights (hf download nvidia/Qwen3.6-35B-A3B-NVFP4, 23.5 GB):

docker run -d --name vllm --restart unless-stopped \
  --device nvidia.com/gpu=all --ipc=host \
  -p 127.0.0.1:8000:8000 \
  -v $HOME/models:/models:ro \
  vllm/vllm-openai@sha256:2a7cde230b59f3ce6cab33dd245ba6bee41aa87b38c9fe84f966ff24016813ce \
  --model /models/Qwen3.6-35B-A3B-NVFP4 \
  --served-model-name qwen3.6-35b-a3b \
  --max-model-len 32768 --max-num-seqs 1 \
  --gpu-memory-utilization 0.5 \
  --attention-backend FLASHINFER --moe-backend marlin \
  --reasoning-parser qwen3 \
  --enable-auto-tool-choice --tool-call-parser qwen3_xml \
  --host 0.0.0.0 --port 8000

The image is pinned by digest (arm64). Docker on that box had no nvidia runtime, so --gpus all failed; the CDI --device form worked.

The OpenClaw side has to match the server. This row ran an agent on that Spark for five days, against a later 262K model:

models: { providers: { spark: {
  baseUrl: "http://127.0.0.1:8000/v1",
  api: "openai-completions",
  timeoutSeconds: 900,
  models: [{
    id: "allspark",
    reasoning: true,
    input: ["text", "image"],
    contextWindow: 262144,  // = --max-model-len
    contextTokens: 196608,
    maxTokens: 16384,
    compat: { supportsTools: true, thinkingFormat: "qwen-chat-template" },
  }],
}}}

For the 32K service above, set contextWindow: 32768 and keep contextTokens + maxTokens under it. thinkingFormat: "qwen-chat-template" comes from docs/providers/vllm.md for Qwen models.

Speed on the Spark with that 262K model (176B MoE, 6B active, FP4): a 34,441-token prompt took 14.4 s to the first token (about 2,400 tokens/s prefill), then 69 tokens/s. 102 of 121 GB RAM was in use.

2 Likes