OpenClaw and Hermes Hardware Requirements: The Honest Version (July 2026)

Bottom Line (July 2026)

• There are two hardware questions, not one. The harness (OpenClaw, Hermes) and the model have completely different requirements, and every tutorial that says “you just need a laptop” is quietly answering only the first one.
• The harness is nearly free. ~1–2GB RAM, a couple of GB of disk, Node. A Raspberry Pi, an old laptop, or a $5–6 VPS all work. Someone in the community runs a 24/7 agent on a £90 M1 MacBook Air with a smashed screen.
• The model is the whole bill. 8GB: harness only, model over a cloud API. 12–16GB VRAM: chat works, agentic tool calling is shaky. 24–32GB VRAM or 32–64GB unified: the first genuinely usable agentic tier. 64–128GB unified: comfortable.
• Context is the hidden requirement. Agents want 64K+ tokens. Community reports put Hermes at a de-facto ~64K floor. Ollama’s small default context is why so many local agents “break after about ten prompts.”
• A VPS runs the harness, not the model. The “$9/month agent” still has an API bill.
• If you only remember one number: 24GB of VRAM is where local agents stop being a demo.

Why Nobody Answers This Question

Go read the comments under any “run your AI agent free and local” video. The top one is always some version of this:

“Creators never go over the hardware needed for these local models. It’s not going to run on the old laptop in your closet.”

Then, a few rows down:

“You forgot to mention that you need a graphics card with sufficient VRAM.”

“does it run on windows laptop with 8GB RAM?”

“Unless you’re running >96gb of VRAM/unified memory, you’re going to have a tonne of compromises.”

Those are all the same complaint, and they are all correct. The tutorials are not exactly lying — the install genuinely does work on a cheap machine. What they leave out is that installing the harness and running the model are two different purchases, and only one of them is cheap.

So let’s split it properly.

Question 1: Can My Machine Run the Harness?

Almost certainly yes.

OpenClaw and Hermes are orchestration layers. They hold the conversation, decide which tool to call, run the tool, feed the result back, and repeat. That is bookkeeping, network calls, and shelling out to other programs. None of it is compute-heavy.

This is why the cheap-hardware stories are real. One setup we like: a £90 M1 MacBook Air with a smashed screen, lid closed, sitting on a shelf, running an agent around the clock. The screen was the broken part. The agent does not need a screen.

For a 24/7 personal agent, the specs that matter are “does it stay on” and “does it have a stable network,” not tokens per second. If your machine sleeps, see the macOS gateway launchd setup.

Question 2: Can My Machine Run the Model?

This is the expensive one, and the honest answer is tiered. The tiers below are about agentic work — multi-step loops with tool calls — which is a much harder bar than chat.

Note what changes between the rows. It is not mainly “smarter model.” It is how much room is left over after the weights load — because that leftover is your context window, and context is what an agent spends.

The Requirement Everyone Forgets: Context

A chat session sends a few thousand tokens. An agent sends the system prompt, the tool definitions, the conversation, and then appends the full output of every tool call it makes — file contents, command output, search results — turn after turn.

That is why agents want 64K or more. Community reports put a de-facto floor around 64K for Hermes specifically, and OpenClaw behaves the same way in practice.

It is also the single most common failure people report:

“It breaks after about ten prompts.”

That is not the model being dumb. That is Ollama’s small default context filling up, the earliest turns falling out of the window, and the agent losing its own instructions mid-task. Set it explicitly:

OLLAMA_CONTEXT_LENGTH=65536 ollama serve

But you have to be able to pay for it in memory. The KV cache for a 64K window lives in VRAM alongside the weights, so the real requirement is weights + cache, not weights alone. A model that “fits” your card with 200MB to spare does not fit your agent. If generation suddenly crawls after you raise the window, the cache spilled to system RAM — see why local LLMs are slow even when they fit.

Which Model at Which Tier

Rather than restate sizes here, these are the tier pages with the model picks and quant sizes already worked out:

• 8 GB — Best local LLMs for 8GB RAM. The 4B and 9B picks. The page’s own verdict on agents is “don’t.”
• 16 GB — Best local LLMs for 16GB RAM. First tier where local LLMs get genuinely useful, and where gpt-oss 20B at Q4 makes short tool-calling sessions work.
• 24 GB — Best local LLMs for 24GB RAM. Also Laguna XS 2.1, whose Q4_K_M is 20.27GB and leaves roughly 8–16K of context on a 24GB card.
• 32 GB — Best local LLMs for 32GB RAM and the 24 vs 32GB breakdown, where the same 20.27GB model gets ~64K of context instead. That context gap is the upgrade.
• 64 GB — Best local LLMs for 64GB RAM, plus Laguna S 2.1 at UD-IQ4_XS (57.6GB) with a capped window.
• 128 GB — Best local LLMs for 128GB RAM. Laguna S 2.1 at UD-Q4_K_M (73.1GB) leaves ~50GB for context and the OS. This is the comfortable tier.

Not sure which tier you are in? Start at the best local LLM by RAM hub, then read best local models for OpenClaw for the agent-specific picks.

One warning that applies at every tier: a model scoring well on chat benchmarks tells you very little about whether it emits clean tool-call JSON under pressure. That is a separate property, and it is the one that decides whether your agent works. Local LLM tool-calling reliability covers which models hold up.

VPS vs Local: The Honest Version

This comes up constantly, usually as “can I just rent a $5 box and run the whole thing there?”

The VPS runs the harness. It does not run the model. A 1–4GB VPS is a genuinely good home for an agent: it never sleeps, it has a stable IP, and it costs less than lunch. The VPS deploy guide covers the $5–6 tiers and Oracle’s free tier.

But a box with 1–4GB of RAM and no GPU cannot host a useful model. So the model goes to an API, and the “$9/month agent” is actually $9/month plus whatever inference costs. That second number is usually the bigger one. OpenClaw monthly cost has the real ranges.

Renting a GPU VPS instead solves the hosting problem and destroys the savings — hourly GPU rental for a 24/7 agent costs far more than an API bill for the same workload, because your agent is idle most of the time and you pay for the GPU anyway.

The three honest configurations:

The third row is underrated. The harness does not need to live on the GPU machine — it just needs to reach it. A Pi or an old laptop as the always-on agent host, pointed at a desktop running Ollama, gets you a 24/7 private agent without leaving a workstation logged in. See remote vs in-home OpenClaw setup.

Does Hermes Need More Than OpenClaw?

For the harness, no — both are lightweight orchestration layers with similar footprints, and people run both on the same machine.

Hermes does keep more on disk over time. It writes episodic memory after each task and generates its own skills, so its storage grows with use in a way a fresh OpenClaw install does not. Budget disk, not RAM, for that. The Hermes vs OpenClaw comparison covers the architectural differences.

Where Hermes is genuinely hungrier is context. Retrieving past episodes and learned skills means more tokens in the prompt before your actual task starts, which is exactly the pressure the ~64K community floor reflects. If you are running Hermes locally, treat 64K as a requirement rather than a nice-to-have, and size your hardware for weights plus that cache.

The Five-Second Version

If someone tells you a local agent runs on any old laptop, they are describing the harness. They are right about the harness and silent about the model.

• Want it always on and cheap? Old laptop or VPS, model over an API. Works today, has a bill.
• Want it fully local and actually agentic? 24GB of VRAM is the entry point, 32GB is where it gets comfortable, and unified-memory Macs at 64–128GB are where you stop thinking about it.
• Want it local on 8GB? Run the harness there and stop pretending the model fits.

Related Guides

• Can I run OpenClaw on 8GB RAM and 8GB VRAM? — the specific low-end case
• Can I run OpenClaw on 16GB RAM? — the next rung up
• Best local LLM by RAM (hub) — pick your tier, then your model
• Best local models for OpenClaw — agent-specific picks
• Local LLM tool-calling reliability — why benchmark scores don’t predict agent behavior
• Why local LLMs are slow even when they fit — the KV cache spill failure mode
• OpenClaw VPS and cloud deploy — the $5–6 harness hosts
• OpenClaw monthly cost — what the API side really costs
• Hermes Agent vs OpenClaw — architecture differences
• OpenClaw defaults to Claude, not Ollama — the config gotcha that makes “local” setups quietly bill you