OpenClaw, Hermes, and the Bet on Local-First Agents

The most interesting thing in the agent space right now isn't a frontier model. It's the quiet consensus that the agent itself — the loop that calls a model, uses tools, and remembers you — belongs on your own machine, talking to you through the apps you already use. Two projects make that case better than anything else I've run this year: OpenClaw and Hermes. They're both real, they overlap a lot, and the contrast between how they're built is the whole point of this post.

What OpenClaw actually is

OpenClaw is Peter Steinberger's open-source personal AI assistant — local-first, model-agnostic, and built to live inside your chat apps (WhatsApp, Telegram, Discord, Slack) instead of in yet another web UI. It runs on your own machine, holds persistent memory of your preferences, and reaches real capability: browser control, file access, shell commands, and integrations with dozens of services. You point it at whatever model you like — Claude, GPT, or a local model through Ollama — and it's explicitly not tied to any one lab.

It got genuinely popular, fast, with the vibe-coding crowd and with developers who liked watching an agent actually carry out multi-step work across their whole environment. In February 2026 Steinberger joined OpenAI. Worth being precise about this, because the internet wasn't: it was an acqui-hire — OpenAI hiring the person and the hard-won operational knowledge of how thousands of people push agents to their limits — not a multi-billion-dollar code buyout. The project continues as open source under an independent foundation, with OpenAI as one sponsor among others, and it stays model-agnostic.

So OpenClaw didn't die, and it wasn't vaporware. It's a real, good, widely-used tool whose creator got hired by the biggest lab in the space. That's the honest starting point.

What Hermes is

Hermes is Nous Research's agent framework, and it takes "self-improving" more literally than anything else I've used. The closed learning loop is the headline: the agent creates skills from experience, refines them during use, persists what it learns, searches its own past conversations with FTS5 + LLM summarization, and builds a deepening Honcho-modeled picture of who you are across sessions. It gets better the longer you talk to it, rather than starting cold every time.

Around that loop, the architecture is aggressively open:

• Model-agnostic. Nous Portal, OpenRouter (200+ models), NVIDIA NIM, Xiaomi MiMo, GLM, Kimi, MiniMax, Hugging Face, OpenAI, or your own endpoint — switch with one command.
• Runs anywhere. Seven terminal backends — local, Docker, SSH, Singularity, Modal, Daytona, Vercel Sandbox. Daytona and Modal hibernate when idle, so a $5 VPS works as well as a GPU cluster.
• Lives where you do. Telegram, Discord, Slack, WhatsApp, Signal, CLI, email — one gateway process, voice memos transcribed automatically, conversation continuity across platforms.
• Real terminal UI. Multiline editing, slash-command autocomplete, history, interrupt-and-redirect, streaming tool output.
• Scheduled automations. Cron with delivery to any platform — daily reports, nightly backups, weekly audits, written in natural language.
• Parallel subagents. Spawn isolated workstreams; write Python that calls tools via RPC to collapse multi-step pipelines into single turns.
• Research-ready. Batch trajectory generation, Atropos RL environments, trajectory compression — the framework doubles as a training-data factory for the next generation of tool-calling models.
• Open standard. Compatible with agentskills.io, so skills are portable and you're not locked into anyone's hub.

If that list reads a lot like OpenClaw's pitch, that's exactly my point. These two are converging on the same shape of product.

Where they actually differ

The agent layer is commoditized, and I mean that as a statement of fact, not an insult. Under the marketing, an agent is a loop that calls an LLM and uses tools — Cline, Roo, Aider, Claude Code, OpenClaw, and Hermes all share that skeleton. The moat was never the loop. So when two good local-first agents look this similar, the question worth asking isn't "which has more features this month," it's "which one's incentives stay pointed at me."

That's where I lean toward Hermes. OpenClaw is excellent and open, but its center of gravity just moved toward a frontier lab — and even with a foundation and a model-agnostic design, attention and direction follow the people. Hermes' whole reason for existing is the open, self-hosted, model-portable path, and its self-improving loop plus training-data angle means the project gets more useful to Nous's research the more it stays open. The incentives and the architecture point the same direction.

The filter I actually use

When I pick an agent in 2026, I weight one thing above the feature checklist — call it substance density: how much of the claim survives 30 minutes of hands-on testing on my own hardware.

• Can I run it without their cloud?
• Can I read the code?
• Does the technical claim survive me poking at it?
• Are real practitioners using it, or just retweeting it?

Both OpenClaw and Hermes pass all four — which is exactly why I trust both and run both. The tools that fail this filter are the closed ones with loud marketing and thin substance, priced like the hype is permanent. Verifiability is the moat now, not virality.

Where I land

I don't think OpenClaw is going anywhere bad — it's open, it's loved, and the acqui-hire is a good outcome for the person who built it. But if I'm betting on which approach defines the agent layer for the long run, it's the one you can fully own: downloadable, auditable, running on your own VPS, talking to you on Telegram, getting smarter every week, and beholden to no single model vendor.

Hermes is the cleanest expression of that bet I've found. OpenClaw proved people want a local-first agent in their chat apps. Hermes is the version I'd wager keeps being mine in three years, no matter who buys whom.