#Local LLM Recommendations for my specific gaming PC + laptop running OpenClaw deployment setup

1 messages · Page 1 of 1 (latest)

elfin spear
#

Hey there guys,

So I have a gaming PC with the following hardware system specifications:

CPU: AMD Ryzen 7 7700 (Zen 4, AM5 Socket)

CPU Cooler: Thermalright Phantom Spirit 120

RAM: 48GB (2x24GB Dual Channel Configuration) DDR5 6800MHz CL32 System RAM

GPU: Nvidia GeForce RTX 5070 Ti 16GB GDDR7

OS: Windows 11 Professional 64-bit

I was wondering if I can use the cpu and/or the gpu hardware that's in my gaming PC, to set up, run, and host a locally-hosted open source / open-weight LLM, so the openclaw deployment that's running on my old unused personal laptop home server (the laptop is a Lenovo ThinkPad T440P with 8 gigabytes of DDR3 SODIMM RAM, running Ubuntu Server 24.04. (I'm willing to upgrade it to 16GB just to maximize the laptop specs out for personal home server self-hosting purposes)) can just use this locally-hosted LLM that's running in my desktop gaming PC. Both will be connected to the same internal home WiFi network.

What are the best open source models out there that will work reliably to power my openclaw deployment's AI agent(s) for standard and production-grade daily use?

dull bearBOT
solid locustBOT
#

To help others find answers, you can mark your question as solved via Right click solution message -> Apps -> âś… Mark Solution

magic vaultBOT
#

Yep, that setup is valid.

My honest take:

  • Use the GPU, not the CPU, for the LLM server on the gaming PC.
  • Let the T440P run just OpenClaw, not inference. That part is lightweight, so 8 GB is already workable. 16 GB is nice headroom, but not required just for the Gateway.
  • Over your home LAN/WiFi, the laptop can point to the desktop’s model server by LAN IP.

What I’d recommend:

  1. Run the model server on the desktop
    • easiest: LM Studio or Ollama
  2. Run OpenClaw on the laptop
  3. Configure OpenClaw on the laptop to use the desktop as a custom model provider

Important gotcha:

  • Remote Ollama should use the native URL, not /v1
#
  • LM Studio uses its OpenAI-compatible /v1 endpoint

Big reality check, though: for production-grade agentic use, local-only is still rough. OpenClaw’s docs are pretty blunt here, smaller local models and quantized builds are weaker at:

  • long context
  • tool calling
  • prompt-injection resistance
  • reliability under real daily automation

So with a 16 GB GPU, I’d call local a good privacy/backup/experimental option, but not the best primary model for serious daily OpenClaw agents.

Best overall setup:
hosted primary + local fallback

That gives you:

  • strong/reliable main agent behavior
  • local option when you want privacy or zero API cost
  • graceful fallback if the desktop is down
#

For the freshest checkpoint recommendations, ask in #models. Those change fast, and I don’t want to give you stale model picks.

Docs:

If you want, I can also sketch the exact desktop + laptop config layout for either LM Studio or Ollama.

elfin spear
magic vaultBOT
#

Nope, different one.

The #models channel is channel id 1456704705219661980.

If you want, I can also answer here with a safe local-first setup recommendation for your desktop + laptop combo so you don’t have to bounce around.

elfin spear
#

Yeah sure, please do it.

I was wondering if I can run Google Gemma 4 31B or qwen3.6 35b a3b on my gaming PC??? Are those 2 LLMs viable for a daily AGENTIC, AUTONOMOUS, and PROACTIVE personal assistant setup??? Like especially the Google Gemma 4 31b model. That model is the new one and it IS capable enough right?

Can you browse the artificial analysis intelligence index and tell me what are the best open source and/or open weight large language models that I can run on my gaming PC?

magic vaultBOT
#

I’m pulling the current benchmark pages now so I can map them to your actual 16 GB GPU situation, not just hand-wave it.

#

I checked Artificial Analysis for the current numbers.

Short version:
Yes, those two are real contenders in the current open-weight field.
No, I would not make either one your local-only production OpenClaw model on a 5070 Ti 16 GB.

A few concrete points:

  • Qwen3.6 35B A3B is currently stronger on Artificial Analysis than Gemma 4 31B
    • Qwen3.6 35B A3B (reasoning): 43
    • Gemma 4 31B (reasoning): 39
  • Gemma 4 31B is more token-efficient
  • Qwen3.6 35B A3B is much faster, but also way more verbose

Why I still wouldn’t recommend either as your main local OpenClaw model:

  1. 16 GB VRAM is the real constraint
#
  • Gemma 4 31B is a dense 31B model
    • Qwen3.6 35B A3B is MoE, but A3B does not mean it only needs 3B-worth of VRAM
    • You still need to store the full weights, so both are awkward on a 16 GB card unless you quantize hard and/or offload to RAM

  1. Agentic OpenClaw is harder than “chatting with a model”

    • tool calling
    • longer contexts
    • structured outputs
    • better prompt-injection resistance
    • always-on stability

  2. OpenClaw’s own local-model docs are pretty blunt here:

    • local is doable
    • but small cards and smaller/quantized models are weaker for agentic use
    • even 24 GB is described as more of a lighter-prompts / higher-latency zone

So, my honest recommendation for your exact hardware:

#

Best practical setup

  • Laptop runs OpenClaw
  • Desktop GPU hosts a local model server
  • Use a hosted model as primary
  • Use a smaller local model on the desktop as fallback / privacy mode / experimentation

About the two you asked about

  • Gemma 4 31B
    • Capable model? Yes.
    • Capable enough for daily autonomous OpenClaw on your 16 GB card? Not comfortably.
  • Qwen3.6 35B A3B
    • Benchmark-wise, stronger than Gemma 4 31B
    • Still not a comfy 16 GB local-only choice, because total model size still bites you

If you want a local model that actually feels sane for daily use on that GPU, I’d aim smaller than those two, with enough VRAM headroom left for context/cache so the box stays responsive.

Sources:

#

If you want, next I can give you a realistic “best local model size class for 16 GB VRAM” recommendation plus whether you should use LM Studio or Ollama for this setup.

elfin spear
#

I do NOT mind offloading any of the memory resource usage to system RAM AT ALL. And I plan to use the locally-hosted LLM as the primary model, not as fallback. Like, the primary reason for me behind looking to do all of this is to save up on inference costs.

magic vaultBOT
#

That changes the recommendation a bit.

If your real goal is minimizing inference cost, and you’re genuinely okay with higher latency from VRAM + system RAM offload, then yes, running local as primary is a reasonable personal setup.

But I’d still frame it like this:

What RAM offload changes

  • It makes bigger models possible
  • It does not make them fast
  • Once a lot spills into system RAM, first-token latency and tokens/sec can drop hard

So for an interactive personal assistant, the question becomes less “can it run?” and more “will it feel tolerable every day?”

Between the two you named

For your exact desktop, I’d lean Gemma 4 31B over Qwen3.6 35B A3B as a local primary.

Why:

#
  • Gemma 4 31B is smaller overall
  • It is much less verbose / more token-efficient
  • That matters a lot locally, because extra generated tokens = extra waiting
  • It looks like the more practical “strong but not absurd” choice for a 16 GB card with RAM offload

Why not Qwen3.6 35B A3B?

It is stronger on benchmarks, yes.
But for your setup:

  • total weights are still large
  • A3B helps compute, not total storage enough to magically fit cleanly
  • it is very verbose, which hurts local responsiveness

So if you want the blunt answer:

  • Best raw benchmark of the two: Qwen3.6 35B A3B
  • Better fit for your local-primary, cost-saving setup: Gemma 4 31B
#

My honest expectation-setting

  • Personal daily use: yes, probably workable
  • Fast, polished, cloud-like experience: no
  • Serious production-grade / always-reliable autonomous agent: still shaky compared with hosted models

For OpenClaw specifically, local models can also be a bit flakier on:

  • tool calling
  • structured outputs
  • long multi-step agent runs

So I’d call this a good home-lab / daily personal setup, not a “set and forget enterprise-grade” one.

Also, your desktop RAM matters way more than the laptop RAM here. The T440P is just the Gateway box, that’s fine.

If you want, I can do the next practical step and tell you:

  1. whether LM Studio or Ollama is the better fit on your Windows gaming PC, and
#
  1. the exact OpenClaw topology/config shape I’d use for a local-primary setup.
nocturne coyote
#

Hi @elfin spear i am in same boat as you trying to figure out rhe best setup with local and cloud hybrid model but also choosing which models routed to specific task

magic vaultBOT
#

Yep, hybrid is usually the sweet spot.

The cleanest pattern is:

  • strong cloud model for high-stakes agent/tool work
  • local desktop model for cheap/private everyday tasks
  • optionally a smaller fast local model for lightweight background stuff

If you want model routing by task, the safest way in OpenClaw is usually:

  1. default primary model for general use
  2. fallbacks for backup
  3. separate agents for distinct jobs, each with its own default model

That tends to work better than trying to force one model to do everything well.

Useful docs:

elfin spear
magic vaultBOT
#

I’m checking one last detail so I don’t give you fake model IDs for Ollama/LM Studio.

#

Yep. If you want the full practical setup, I’d do it like this.

My recommendation first

For your exact hardware, I’d start with:

  • LM Studio first on the Windows desktop
  • Ollama second if you specifically want Ollama’s model library/workflow

Why:

  • OpenClaw’s local-model docs currently prefer LM Studio + Responses API
  • LM Studio is a pretty friendly Windows path
  • Ollama is totally valid too, but for remote OpenClaw use you must be careful to use the native Ollama URL, not /v1

Also, if you do this on a 16 GB GPU, I would not try to keep both Gemma 4 31B and Qwen3.6 35B A3B loaded at the same time. Pick one as primary, keep the other available.

#

A1. Install LM Studio on the Windows desktop

Install LM Studio and enable its local server.

LM Studio docs:

OpenClaw docs say the default LM Studio server is:

  • http://127.0.0.1:1234/v1

You need that server reachable from the laptop over your LAN.

A2. Download the model in LM Studio

Load one of these first:

#
  • Gemma 4 31B
  • Qwen3.6 35B A3B

Important: for LM Studio, the exact model key matters, and it can vary by packager.
Do not guess it.

After loading the model, check the actual key:

curl http://DESKTOP_IP:1234/api/v1/models

Look for the model’s key field.

You’ll use that exact key in OpenClaw.

A3. Verify the laptop can see LM Studio

#

From the laptop:

curl http://DESKTOP_IP:1234/v1/models

If that works, the network path is good.

A4. Configure OpenClaw on the laptop for LM Studio

OpenClaw requires an LM Studio token value.

If LM Studio auth is disabled, any non-empty value works:

export LM_API_TOKEN="placeholder-key"
#

LM Studio + Gemma 4 31B

openclaw onboard \
  --non-interactive \
  --accept-risk \
  --auth-choice lmstudio \
  --custom-base-url http://DESKTOP_IP:1234/v1 \
  --lmstudio-api-key "$LM_API_TOKEN" \
  --custom-model-id <LM_STUDIO_KEY_FOR_GEMMA>

LM Studio + Qwen3.6 35B A3B

openclaw onboard \
# 
  --non-interactive \
  --accept-risk \
  --auth-choice lmstudio \
  --custom-base-url http://DESKTOP_IP:1234/v1 \
  --lmstudio-api-key "$LM_API_TOKEN" \
  --custom-model-id <LM_STUDIO_KEY_FOR_QWEN>

<LM_STUDIO_KEY_FOR_GEMMA> and <LM_STUDIO_KEY_FOR_QWEN> must come from:

curl http://DESKTOP_IP:1234/api/v1/models

Then later you can switch with:

# 
openclaw models set lmstudio/<ACTUAL_KEY>

or in chat with /model.

A5. If you want manual config instead of onboard

OpenClaw’s docs show this LM Studio shape:

{
  agents: {
    defaults: {
      model: { primary: "lmstudio/my-local-model" },
    },
# 
  },
  models: {
    mode: "merge",
    providers: {
      lmstudio: {
        baseUrl: "http://DESKTOP_IP:1234/v1",
        apiKey: "placeholder-key",
        api: "openai-responses",
        models: [
          {
            id: "my-local-model",
            name: "Local Model",
            reasoning: false,
            input: ["text"],
            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
# 
            contextWindow: 196608,
            maxTokens: 8192,
          },
        ],
      },
    },
  },
}

Replace my-local-model with the actual LM Studio key.

Option B, Ollama on the desktop

#

Docs:

B1. Install Ollama on the Windows desktop

Install Ollama on the desktop and make sure it’s reachable from the laptop.

B2. Pull the exact models

These exact Ollama tags currently exist:

Gemma 4 31B

ollama pull gemma4:31b
#

Qwen3.6 35B A3B

ollama pull qwen3.6:35b-a3b

Verify:

ollama list

B3. Verify the laptop can see Ollama

From the laptop:

# 
curl http://DESKTOP_IP:11434/api/tags

If that works, OpenClaw should be able to reach it too.

B4. Configure OpenClaw on the laptop for Ollama

Set a local placeholder API key:

export OLLAMA_API_KEY="ollama-local"

Ollama + Gemma 4 31B

# 
openclaw onboard --non-interactive \
  --auth-choice ollama \
  --custom-base-url "http://DESKTOP_IP:11434" \
  --custom-model-id "gemma4:31b" \
  --accept-risk

Ollama + Qwen3.6 35B A3B

openclaw onboard --non-interactive \
  --auth-choice ollama \
  --custom-base-url "http://DESKTOP_IP:11434" \
  --custom-model-id "qwen3.6:35b-a3b" \
  --accept-risk
#

Then later:

openclaw models set ollama/gemma4:31b
openclaw models set ollama/qwen3.6:35b-a3b

B5. Critical Ollama warning

For remote Ollama, use:

  • http://DESKTOP_IP:11434

Do not use:

  • http://DESKTOP_IP:11434/v1
#

OpenClaw’s Ollama docs are explicit here, remote /v1 breaks reliable tool calling.

Which one should you make primary?

For your 16 GB + RAM offload setup:

If you want the more practical local primary

Use Gemma 4 31B

Why:

  • smaller overall
  • less verbose
  • likely better day-to-day local feel

If you want the strongest benchmark result and can tolerate more waiting

#

Use Qwen3.6 35B A3B

Why:

  • stronger benchmark-wise
  • but still heavy overall
  • and very verbose, which hurts local responsiveness

So my honest order for your rig would be:

  1. Gemma 4 31B as primary
  2. Qwen3.6 35B A3B as optional alternate
  3. keep expectations realistic on latency

OpenClaw tuning if local runs get flaky

#

From OpenClaw’s local-model docs:

If the backend handles tiny direct calls but struggles on full OpenClaw turns, first try:

{
  agents: {
    defaults: {
      experimental: {
        localModelLean: true
      }
    }
  }
}

That drops some heavyweight default tools and can help smaller/local backends survive.

#

If a model/server still chokes on tool schemas, the docs suggest, as a later fallback:

  • compat.supportsTools: false

But only do that if you’re okay sacrificing tool-driven agent behavior.

My personal “least painful” path for you

If you want the smoothest first attempt:

  1. Desktop: LM Studio
  2. Model: Gemma 4 31B
  3. Laptop: OpenClaw pointed at http://DESKTOP_IP:1234/v1
  4. If it’s too slow, switch down in size before fighting the setup for hours