The first time my agent forgot who I was, I blamed the config. The twelfth time, I blamed the architecture.

I’d been running OpenClaw for weeks now. Building workflows, storing preferences, training my agent to work the way I work. And every few weeks, something would slip. A project decision I’d explained twice already. A formatting rule I’d set three conversations ago. Context that should have been obvious, gone.

A week after I stopped blaming myself, I installed Hermes. A month later, going back never crossed my mind.

This is the migration guide I wish someone had written for me.

In this article:

1. Why I Moved

2. The Tradeoff

3. Before You Start

4. The Migration

5. The Gateway

6. Your First Week

7. The Honcho Difference

8. First Bumps

9. The Bottom Line

Why I Moved

OpenClaw carried me for a few weeks. I built workflows, connected it to Nextcloud, ran it alongside Claude Cowork, and wrote about the whole setup on this newsletter. The tool works.

But the longer I used it, the more I noticed where it fought me.

Instructions. I’d write a detailed prompt telling my agent exactly how to handle a task. OpenClaw would get 70% of it right and improvise the rest. I’d rewrite. It’d still miss the same parts. After enough rounds of this, I realized the problem wasn’t my prompting. The framework itself was cutting corners on how it passed instructions to the model.

Hermes fixed this on day one. The same prompts that produced mediocre results in OpenClaw produced exactly what I asked for in Hermes. It does use more tokens per interaction, so the API bill goes up. But the outputs land closer to what you asked for, every time.

Memory. I wrote an entire article about OpenClaw’s memory problem. Lossless Claw patched it. The patch worked, mostly. But it was still a patch on a system that wasn’t designed for persistent memory from the ground up.

Security. In January 2026, a published security audit reported 512 vulnerabilities in OpenClaw, including one allowing remote code execution through a single malicious link. Researchers at Cisco found 335 malicious skills on ClawHub. I’d been running this on my server with access to my files, API keys, and personal documents.

Reading those reports accelerated my timeline. I was already leaning toward Hermes.

The Tradeoff

Hermes is better for me. It might not be better for you. Here’s both sides.

What got better:

Instruction following. Hermes reads your full prompt and executes it. The token cost is higher because it runs more tools, creates skills to standardize processes and basically processes more of your instructions instead of skipping them. It likes to be super thorough.

Setup. Installing Hermes took less time than any OpenClaw update I’ve done. The setup wizard walks you through everything, detects your existing OpenClaw install, and offers to bring your data over automatically.

Memory. Honcho runs as a separate memory layer. You can just sign up and get $100 for it. Your conversations persist across restarts, model switches, and gateway reboots. I am playing with the local install to use my own models and keep my memory safe and hosted locally.

Self-improving skills. When Hermes solves a hard problem for you, it writes a reusable skill document. Next time a similar task comes up, it’s faster and will actually know what to do. OpenClaw never did this.

What got worse:

Model providers. OpenClaw works with a massive list of providers. Hermes doesn’t. If you depend on a specific model through a specific provider, check compatibility before you commit.

Token usage. Your API bill will go up. Mine increased by roughly 20%. The outputs are better, so the cost per useful result is about the same. But the raw number on your invoice will be higher. This is a price I am willing to pay just for the model to actually listen to my instructions.

Ecosystem. OpenClaw has ClawHub with thousands of community skills. Hermes has a smaller library. The self-improving skills system offsets this over time, but on day one you’ll have fewer pre-built options.

Before You Start

Two things to do before you install Hermes.

Back up your OpenClaw config. Copy your ~/.openclaw/ directory somewhere safe. Your .env files, your skill definitions, your SOUL.md. Hermes will import most of this automatically, but having a backup costs you thirty seconds and saves you from a bad day.

cp -r ~/.openclaw/ ~/openclaw-backup/

Check your model providers. Open your OpenClaw .env file and look at which providers you’re using. Visit the Hermes docs and confirm they’re supported. If your primary model works, you’re good. If it doesn’t, figure out your alternative before you start.

Hermes handles everything else.

Migrating Is Straightforward

Install Hermes on your server. The first time you run hermes setup, it detects your OpenClaw installation and asks if you want to import your data.

Say yes.

The setup wizard pulls in your memories, your SOUL.md (your agent’s personality and system prompt) and your preferred channels (I use Telegram).

What you’ll need to redo by hand:

Any API keys or secrets that weren’t on the allowlist get skipped. The setup tells you exactly which ones it skipped and why. Add them to ~/.hermes/.env manually.

If you were using ClawHub marketplace skills, those don’t transfer. Recreate the ones you need in the Hermes skill format, or check if the Hermes community has equivalents.

The entire process took me about fifteen minutes. Most of it was copying over API keys and recreating some skills.

Hermes Gateway

Hermes centralizes your gateway config in one file: ~/.hermes/config.yaml.

Run Hermes with hermes and ask it to configure the messaging channels for you, or just do it manually.

If you were on Telegram with OpenClaw, the setup looks like this:

gateway:
  platform: telegram
  telegram:
    bot_token: ${TELEGRAM_BOT_TOKEN}
  port: 8082

Add your bot token to ~/.hermes/.env, point the config at it, and start the gateway. Open Telegram and send your agent a message. If it responds, you’re live.

For Discord, Slack, WhatsApp, or Signal, the pattern is the same. One platform block in the config file, one token in the env file. The Hermes docs list every supported platform with copy-paste examples.

I switched my Telegram bot to Hermes and sent it a test message within two minutes of finishing the migration. It responded with context from my last OpenClaw conversation. The memory import worked.

Your First Week

The first thing you’ll notice is that your agent listens better.

I gave Hermes a content brief with twelve specific formatting rules. It followed all twelve. The same brief in OpenClaw would produce something that hit eight or nine, with two or three “creative interpretations” I didn’t ask for.

The second thing you’ll notice is the token counter. My daily usage went up noticeably. Hermes processes more of the conversation context on every turn, and it doesn’t shy away from calling tools, which is why the instruction following is better. You’re paying for the model to read more and skip less.

In a single conversation Hermes had created two skill documents on its own. One for how I like my research summaries formatted. Another for the file naming convention I use in my Nextcloud docs folder. I didn’t ask it to learn these things. It picked them up from our conversations and wrote reusable procedures.

If you built the Nextcloud bridge from my earlier article, it works with Hermes too. Point Hermes at the same synced folder and your shared brain carries over. Nothing changes on the file sync side.

Honcho Makes a Difference

The real memory system in Hermes is called Honcho, and it’s a 3rd party tool.

It stores your conversations, builds a profile of who you are and how you work, and serves that context back to the agent at the start of every interaction.

I chanted with Hermes using the TUI and then asked it something on Telegram. It picked up exactly where we left off. The context from Friday’s conversation was also there. The decisions we made on Monday were referenced correctly.

I tested the same scenario in OpenClaw before I migrated. The agent remembered some fragments through vector search. It missed the thread connecting them. I spent ten minutes re-explaining what we’d already decided.

According to Honcho’s published pricing, it costs $2 per million tokens ingested. Every context retrieval call is free with no limits. Based on my usage patterns, it adds a few dollars a month to my total cost. For the amount of time it saves me re-explaining context, it’s the cheapest upgrade in my entire stack.

Nevertheless, I am a die-hard fan of self hosting and you can actually self host Honcho. I wanted to give it a try first before committing but now I am sold.

Drop a comment if you’ve already made the switch. I want to hear what your first week looked like.

Leave a comment

First Bumps

The migration went smoothly, but the first few days had a couple of bumps. Here’s what I ran into and how I fixed it.

Skills not loading. One of my imported skills had a formatting issue in its SKILL.md file. Hermes skipped it silently. I checked ~/.hermes/skills/openclaw-imports/, opened each file, and found a broken YAML header. Fixed the formatting, restarted, done.

Token spikes. My first full day of usage ran higher than my OpenClaw average. By day three it settled to about 20% above baseline. The spike on day one was Honcho ingesting my conversation history and building the initial context graph.

Missing env variables. I forgot to move one API key from my backup into ~/.hermes/.env. The error message told me exactly which key was missing and which skill needed it. Added the key, restarted, fixed.

For anything else, the same pattern from my Nextcloud article applies. Copy the error message, paste it to your agent, and let it diagnose the problem. Hermes is better at debugging itself than OpenClaw because it retains the context of what went wrong and what was already tried.

The Bottom Line

If you’re building long-term workflows where context matters, where your agent needs to remember what you decided last week and why, migrate now. Hermes was built for this from the ground up, and the migration wizard makes the switch painless.

If you’re running simple one-off automations and OpenClaw handles them fine, stay put. There’s no reason to move if your current setup does what you need.

For everyone in between, it takes fifteen minutes and a slightly higher API bill. You get an agent that follows your instructions, remembers your preferences, and gets better at your specific workflows every day it runs.

I moved a week ago. The only thing I regret is not moving sooner.