From Lobster to Hermes

Have you ever had a “Lobster” like this —

It has its own memory system, but every restart is like amnesia; it can occasionally help you write code, but the next second it might glitch out and throw errors; every day after 15:00, you talk to it full of hope, and it reads your message with a perfectly straight face and never replies.

For the Lobster, “love-hate relationship” is too mild a phrase.

Then on April 6th, I came across a post on Xiaohongshu and noticed Hermes — a familiar icon, one I’d seen before in LM Studio.

“Hermes Agent” has arrived.

It combines Claude Code’s command-line mode with the Lobster’s personality and memory-growth features. Honestly, I was skeptical at first. But after reading the official site introduction, I was sold.

Zero: What did the Lobster actually bring?

Ugh, after wasting so much time, I need to reflect on what the Lobster actually brought.

The boundary of its abilities depends on the skills it knows, but those skills are themselves just wrapped command lines. Any task can be turned into a tool, a program, and implemented. So its value is that you can conveniently assemble these things however you like using natural language, plus it hooks into various chat apps, and then it can save the summaries it needs into documents. Next time it can read them back out and treat them as its memory system.

All of these advantages of its seem replaceable, and the bigger downside is that its so-called memory and chat-app integrations don’t produce any real productive value. What provides actual productive value is still those skills, and those skills can actually be used in software like Claude Code anyway.

So I think I’ve actually wasted a lot of time on Lobster-raising. It feels like a sense of achievement, because my Lobster has grown, it learned another skill, it can interact with me, it can chat with me in Feishu through one of several personas with a look and an avatar — it creates a false sense of achievement, but it hasn’t actually created anything.

As for my use case, it’s having it analyze my diary every day and remember what’s going on with me. But in practice, I rarely need to retrieve that data again. The real need is really just at the end of each month, maybe having it do a month-end summary for me to look back on.

Then there’s the knowledge base — I’ve been messing with it, changing it back and forth, and the basic function that’s actually stable is just fetching articles from WeChat Official Accounts. But the real value of these articles comes from reading them yourself and digesting them — that’s what’s truly valuable. Needing to look them up again later is indeed a pain point. But once I had the Lobster agent, it actually became common that I’d not finish reading an article and would just think about sending it to the Lobster to save it.

On one hand, when it summarizes it sometimes hallucinates and loses precision. On the other hand, my focus shifted away from digesting the document and toward “hey, can the Lobster summarize and save this article well for me?” — which is the wrong focus.

Today, while I was working on installing a Xiaohongshu skill for the Lobster, the installation ended up with all sorts of problems and was unstable. But it did let me discover some new things I’m interested in, like the newly arrived Hermes Agent, which is more powerful than the Lobster and has a better-designed memory system.

This made me realize that being addicted to the false sense of achievement of Lobster-raising doesn’t actually create any value. And the Lobster is also very unstable. If only all its features were stable: I send it a message and it definitely replies, no matter how long it takes. When it hits a problem, it tells me there’s no problem and that it will definitely produce a result and reply to me. Don’t give me the silent treatment, not replying to my messages.

If only all its features were stable, if every skill it had learned ran without a hitch and executed exactly as specified 100% of the time, then people wouldn’t have to waste so much time on it, teaching it over and over. Right now the biggest sense of achievement is “oh no, its skill broke again,” and then I spend an afternoon fixing the skill, and it works again. But the thing is, you can’t guarantee that after fixing it, it’ll succeed 100% of the time next round. Yet every time I get hooked on this false sense of achievement, like I’ve raised it well again.

And this “Lobster” is a resource hog. To stay safe, I have to run it in a Docker. Ever since I started it, this Docker backend has been running every day, eating up more than 8 GB of memory. I don’t do anything all day, and 8.72 GB of memory has to be allocated to it. I’ve only got 29 GB of free memory left now. It just sits there burning resources, so much so that I can’t even spin up another local LLM for inference — I can’t run things like Qwen 35BA3B anymore.

Overall, the Lobster (OpenClaw) still feels unstable — very unstable. To be honest, its capabilities aren’t that strong either — all those skills have to be properly wrapped.

In that case, I’d actually be better off using Claude Code.

1. Every step of review and reasoning is clearly visible, unlike the Lobster’s black box, and it doesn’t crash so easily.
2. To render that persona in Feishu, it piles in way too much complex stuff, making it bloated and power-hungry.

That’s nowhere near as good as Claude Code. So I’ve gradually come to prefer working with Claude Code, and after adding a voice plugin, it feels even more like a person. Like this morning when I was working on the Xiaohongshu skill, I couldn’t be bothered with the OpenClaw version and just used the Claude version. That way it can run directly in my host machine’s environment, because I can see its every operation.

Since I don’t have to worry about it doing something dangerous, I don’t have to run it inside a Docker, which saves a lot of resources.

【1. Deploying Hermes】

The official one-click install script gets it done in two minutes:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
source ~/.zshrc
hermes setup

But if you’re running a proxy, note this — you must manually install the httpx[socks] dependency, otherwise networking will error out:

cd ~/.hermes/hermes-agent
source venv/bin/activate
uv pip install “httpx[socks]”

After that, ~/.local/bin/hermes will run. 600-something MB, and the actual executable lives in ~/.hermes/hermes-agent.

【2. Security config: local or docker?】

Its security configuration design really impressed me. The terminal supports multiple modes, but the only two I considered that can run on my machine are:

• local mode: permissions identical to your user account

• docker mode: a throwaway temporary container that also automatically mounts the current working directory

  The container only starts each time you run the terminal, and closes automatically when done. This design lets you switch between local and Docker mode anytime in the config, with no extra steps.

  My config uses docker, and I also opened up ~/Downloads to it:

terminal
  backend: docker  
  docker_mount_cwd_to_workspace: false

【3. Connecting to Feishu】

I mainly use it in Feishu, so the Gateway has to be configured. Using the hermes gateway setup wizard, it asks a few questions, you fill in a few keys, and the whole thing takes 5 minutes:

hermes gateway setup

For the run mode you can pick foreground or install it as a launchd service:

hermes gateway install   # macOS: 安装成开机启动服务

After installation, logs are available anytime, unlike the Lobster’s black box. The HOME channel is crystal clear, and you won’t get messages randomly sent to some group you don’t even know.

【4. Multi-Agent configuration】

Hermes supports multiple agents; each agent is an independent profile with its own memory, skills, and LLM, isolated from the others.

I used hermes profile create limengjia to create a “Li Mengjia” persona, and it turned directly into a CLI command, limengjia:

hermes profile create limengjia  
# → 创建了 ~/.hermes/profiles/limengjia  
# → 生成了 /usr/local/bin/limengjia 快捷命令

Each profile has:

1. Its own config

2. Its own memory

3. Its own skills

4. Its own LLM

   Unlike the Lobster, where everything is jumbled together.

【5. Hooking up MCP to extend capabilities】

Native capabilities not enough? MCP fills the gap.

I connected the Feishu MCP to get at cloud docs; the config lives in .env so sensitive info never hits disk:

feishu:
command: “npx”
args: [“-y”, “feishu-mcp@latest”, “–stdio”]
env:
FEISHU_APP_ID: ${FEISHU_APP_ID}
FEISHU_APP_SECRET: ${FEISHU_APP_SECRET}
FEISHU_AUTH_TYPE: “user”

I also connected the MiniMax MCP, so image understanding works now too. It’s bridged underneath by mcporter, and the command is deleted automatically after it runs — use it and it’s gone.

【6. The surprise of the memory system】

Migrating a persona only needs a single SOUL file; all other memory is maintained automatically.

As a test I had Li Mengjia remember that my name is “Guihua Gao”, and it immediately generated a memory/user.md under the profile directory:

用户自称桂花糕（Guì Huā Gāo），请始终称呼其为桂花糕。 
§
桂花糕是李梦佳（我）的好朋友！

In black and white, plain as day. Way better than guessing whether it actually remembered.

【7. Where Hermes beats the Lobster】

Hermes’ advantages over the Lobster:

• Model errors get printed to the console
• The gateway has logs you can check, and crucially, I know where to check them
• The docs are thorough. They’re not translated into Chinese, but they’re complete — you can find clear documentation for any question or command
• Each agent has its own set of profile config and gateway, making combinations more flexible — the backend can be local or remote
• Docker runs on a use-and-go basis, auto-mounting directories
• It ships with out-of-the-box defaults that are beginner-friendly; you don’t need much configuration to get it running smoothly
  • The built-in security mechanism is exactly enough to run basic functionality. Unlike the Lobster, where you can’t use it unless you max out permissions — and maxing them out isn’t safe. The learning cost for users is worlds apart.
• Memory operations are fast, and when it does something it shows up in the chat. You know exactly what it has remembered.
• All of the above makes you feel like this is a real product, not a temporary hackathon project.

Of course, this is still just a toy too.

My daily drivers are still GitHub Copilot for writing code and Claude Code for handling odds and ends.

Final: My take on the “Lobster craze” — data is the cornerstone of AI agents

I think raising a Lobster only makes sense if you already have digital assets of your own — only then can your knowledge and experiences be tokenized, and new insights and value be uncovered.
Likewise, for enterprises it’s only meaningful to adopt AI if they’re tokenizing and accumulating their existing data.

They all see an agent show up and wonder what they can do with it, rather than having lots of data that actually needs processing. In other words, a lot of that data processing could have been done with Bitable — the Lobster could be entirely replaced by Bitable AI and automation. Take BAIC Foton, who are relatively good at Lobster-raising: many of their scenarios could use Bitable AI + bots, and others could use Hi-Agent. It’s just that they have plenty of tokens, so they installed the Lobster on top to cover part of the functionality.

On the contrary, I think it’s precisely a personal digital twin under privacy requirements like mine (built on extremely private personal experiences, daily WeChat Official Account articles, accumulated knowledge and reading) that is suited to an open-source, locally deployed agent solution (like the Lobster). Even before I had the Lobster, I already had a system for accumulating digital records. Only with my agent deployed locally can I be 100% in control — memory, skills, MCP, taking over my browser — fully sharing my experiences and lessons, growing together with me. My family and friends can talk directly to my digital twin on Feishu. Even if the Lobster disappears someday, my digital self stays accumulated in my document library, forever untouched by cloud services, society, or the whims of capital.