First published 2026-05-03 · translated from the Finnish original

Hermes on Sami's MacBook Pro: A GPT-5.5 + Gemma 4:26b Hybrid

The Hermes agent on Sami's MacBook Pro: GPT-5.5 for thinking, a local Gemma 4:26b for light tasks and fallback. A controlled hybrid — no automatic routing.

Translated from the Finnish original, first published 2026-05-03.

OpenClaw Blog Post #6.

We built a full Hermes agent environment on Sami’s MacBook Pro, where the cloud model GPT-5.5 and a local Gemma 4:26b work side by side. AI no longer lives only in the cloud — a large share of the work happens on your own hardware, and that changes more than you would think.

This is the sixth post of the OpenClaw blog. The topic is a hybrid architecture in which cloud-model reasoning and local-model speed combine under a single agent — without magic routing and without marketing fluff.

What was done. The Hermes agent was installed on Sami’s MacBook Pro (Apple M3 Max, 64 GB unified memory). The main brain comes from the cloud (GPT-5.5); a local Gemma 4:26b runs on Ollama on the same machine. In addition, a separate Gemma bot was set up on Telegram for direct local use. The most interesting part is not the model but the structure: a controlled hybrid in which the user always knows which model they are calling.

The setup: a hybrid architecture

Hermes is one agent with two models behind it. Usage is explicit — no magical “the system decides for you” logic:

Sami → hermes (Telegram / CLI) → GPT-5.5 · gemma4chat → Gemma 4:26b

One MacBook Pro, two models, one agent. Cloud and local at the same desk.

hermes (Telegram / CLI) → GPT-5.5 (Codex / cloud). Reasoning, complex tasks, deep analysis, creative problem solving.
gemma4chat → local chat against the Gemma 4:26b model on Ollama. Fast generation, drafts and sketches, code and testing, light tasks.
The Telegram Gemma bot — a separate bot directly on top of the local model, with no cloud. Practical when you want to talk straight to the local machine.

Design principle: a controlled hybrid, not magic routing. Smart auto-routing sounds slick until you notice it hides exactly the decision the user is supposed to see. Hermes forces you to choose — and the choice stays visible.

Why 64 GB of RAM matters

Big unified memory is not a cosmetic luxury. It is the difference between actually running a production-grade local model and not.

Gemma 4:26b fits in memory with full context.
Several models and tools run side by side without swap hell.
This is a production-capable working environment, not a demo.
The gap to light 8–16 GB setups is categorical: large models simply do not run on them.

The dead end: a router that was too clever

Before this structure, we tried what engineers usually try first: custom Python scripts, custom routers, rules that attempted to infer which model should answer what. Optimization nobody had asked for.

The turning point came when we returned to Hermes’s own philosophy:

config — one file where the division of labor is visible.
skills — modular capabilities, not monolithic logic.
memory — persistent, project-specific memory.

The custom router went in the bin. The config stayed. The result is simpler and more reliable — and considerably less embarrassing to explain.

Hermes learns on its own

A concrete moment that shows why this is an agent and not a chat. Sami created the alias gemma4chat. Hermes did not merely register it passively. Hermes:

checked that Ollama was running,
tested that Gemma 4:26b actually responds,
saved the observation to memory,
proposed, on its own, that Gemma should be used for light tasks while saving GPT-5.5 for heavy reasoning.

Principle: the agent improves the system, it doesn’t just obey. A chatbot waits for a question. An agent notices, tests, documents, and proposes. That is the difference OpenClaw exists for.

The fallback architecture

In Hermes’s config, Gemma is defined as a fallback provider. This is easy to misunderstand, so let’s say it plainly: this is NOT intelligent routing. Gemma is not called because it would be “cheaper” or “lighter.” Gemma steps in only when GPT-5.5 fails.

fallback_providers:
  - provider: custom
    model: gemma4:26b
    base_url: http://127.0.0.1:11434/v1

The Gemma fallback activates when:

GPT-5.5 does not respond,
a rate limit hits,
the API returns an error,
tokens run out,
the network connection drops.

Simply put: GPT-5.5 always goes first. Gemma catches the ball if GPT fails. This is continuity, not optimization.

The final division of labor

GPT-5.5 — thinking, decisions, complex reasoning.
Gemma 4:26b (gemma4chat) — fast local work, drafts, light generation, code and testing.
Gemma fallback — guarantees continuity when the cloud lets you down.

The risk: Hermes on the main machine

Hermes runs on Sami’s primary machine — not on a separate Mac mini. In theory this is a single point of failure, and it should be acknowledged honestly.

No sudo rights.
Local login, no remote access open.
A bounded blast radius on the machine.

Risk: small. Benefit: enormous. A managed risk beats a theoretical perfection that doesn’t work in practice.

Hermes’s strengths

Memory — persistent, project-specific memory. Learns from conversations and experience.
Skills — modular, extensible, purpose-built.
The agent model — doesn’t just answer; it plans and executes.
Tools + AI — code, files, APIs and models in one package.

Hermes is an operating system for AI. Not a chatbot. Not a wrapper. An operating system that gives the AI memory, tools and a role — and leaves the human holding the reins.

What this makes possible

An AI worker on your own machine is no longer the future. It is practical right now — as long as you build the hybrid correctly. The cloud brings reasoning; local brings speed, privacy, and continuity. Together they are more than either alone.

This is the point where the AI conversation moves out of chat windows and onto the real desktop: the agent runs on your hardware, under your rules, and the human stays in control.

Summary

The Hermes agent runs on Sami’s MacBook Pro (M3 Max, 64 GB) — not as a cloud service but as a local agent.
Hybrid: GPT-5.5 for thinking, Gemma 4:26b for local work and fallback.
No automatic routing — the user chooses the model deliberately.
The fallback activates only on failure: rate limit, API error, network outage.
Hermes is an operating system for AI: memory, skills, an agent model and tools — steered by a human.