Hermes Agent one-click deployment script is now live, and OpenClaw finally has a memory-capable replacement.

Nous Research’s Hermes Agent exploded in popularity this week. It’s been on GitHub for less than a week and has already gathered 28.4k stars—people are discussing it everywhere in the community. In short: it’s an intelligent agent framework that can build and retain its own long-term memory, and it even includes a one-click migration script specifically for OpenClaw users.

Put simply, it’s aiming straight at OpenClaw’s weaknesses.

OpenClaw’s Longstanding Issues—People Have Had Enough

OpenClaw is a veteran in the intelligent agent framework world. It has a rich plugin ecosystem and broad functionality coverage—most developers working on task automation have used it. But they all know one major pain point: terrible memory retention.

You can spend half an hour teaching it a full workflow—how to handle emails, organize documents, or generate weekly reports—and it will learn it well at first. A few days later, you open it again, and it’s forgotten everything. You have to start from scratch. This isn’t a random bug but a structural flaw: OpenClaw lacks a real persistent memory mechanism. Context between sessions is held together by plugins and external storage, and once the chain breaks, so does the memory.

The community calls this the “Lobster Blackout.”

Even worse, there’s the security factor. In February, several high-risk vulnerabilities in OpenClaw were exposed, affecting about 135,000 users. Although later patched, trust once broken is hard to rebuild.

Hermes Agent emerged in this context.

What Hermes Agent Got Right

Let’s start with its core selling point: the Built-in Learning Loop.

This is not marketing fluff—it’s an architectural design choice. Traditional intelligent agents work in a “you say, I do” pattern—you give commands, it executes, and you have to instruct it again next time. Hermes Agent adds an extra layer: it autonomously extracts skills from each completed task, stores them persistently, and automatically calls and optimizes them when faced with similar tasks later.

A concrete example: when you first ask it to categorize GitHub issues by priority and generate a daily report, it goes step by step. Once finished, it abstracts that process into a stored skill. The next day, you just say “Generate today’s report,” and it already knows what to do. If you correct its categorization logic midway, it updates the skill and applies the new logic next time.

This capability relies on several key components:

• FTS5 full-text search engine for conversation retrieval—memory recall across sessions is no longer guesswork
• LLM-driven summarization to condense long conversations into structured knowledge
• Continuous user modeling—the more you use it, the better it understands your preferences, habits, and work patterns

It doesn’t sound overly complex, but no one had packaged such functionality into an out-of-the-box open-source framework before. In OpenClaw, achieving the same effect requires integrating a vector store, writing a memory plugin, and gluing together a bunch of code. Hermes Agent ships with it built in.

Lightweight Design—And It’s Serious About It

Another complaint about OpenClaw: it’s heavy. Deploying a full OpenClaw service means battling dependencies for hours, and it’s resource-hungry once running.

Hermes Agent takes the opposite route: modular design, single-process gateway, and runs even on a lightweight $5 VPS. It supports Daytona and Modal for serverless operation—when the agent isn’t in use, it automatically sleeps and wakes instantly when needed, costing almost nothing while idle.

For indie developers and small teams, this difference is very real—you no longer need a dedicated 2C4G machine just to keep an agent alive.

Platform compatibility is thorough, too: native support for Telegram, Discord, Slack, WhatsApp, and Signal; CLI interface supports multiline editing, auto-completion, and streaming output. However, community feedback notes that only the default chat mode currently supports streaming; other modes are still being adapted—worth noting if your workflow depends on that.

Model Switching: One Command Away

This is something developers really care about. Hermes Agent handles model integration flexibly—compatible with Nous Portal, OpenRouter (200+ models), z.ai/GLM, Kimi/Moonshot, MiniMax, OpenAI, and others. Switching models takes only one command:

hermes model

No code modification, no config file editing—just pick interactively in the CLI. No vendor lock-in.

If you use an OpenAI-compatible API aggregation service (like OpenAI Hub), integration is seamless since Hermes Agent natively supports the standard OpenAI API schema. After configuring a custom endpoint, you can use a single key to call GPT, Claude, Gemini, DeepSeek, and others—even directly within domestic network environments, without fiddling with proxies.

Typical pattern for calling different models in an agent context:

import openai

client = openai.OpenAI(
    api_key="your-openai-hub-key",
    base_url="https://api.openai-hub.com/v1"
)

# Same client, switch models easily
response = client.chat.completions.create(
    model="claude-sonnet-4-20250514",  # or gpt-4o, gemini-2.5-pro, deepseek-chat
    messages=[
        {"role": "system", "content": "You are a task automation assistant"},
        {"role": "user", "content": "Help me organize today’s GitHub notifications and group them by project"}
    ],
    stream=True
)

for chunk in response:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

This flexibility is extremely valuable in practice—you can route simple tasks to budget models and complex reasoning to stronger ones, balancing cost and performance.

One-Click Migration: Moving from OpenClaw

This is the smartest part of Hermes Agent’s rollout. It doesn’t ask users to start from scratch—it provides an OpenClaw migration tool that automatically imports settings, memory, skills, and API keys.

Installation is itself a one-liner:

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

Supports Linux, macOS, and WSL2. Windows users need to install WSL2 first.

After installation, reload your shell:

source ~/.bashrc    # For zsh users: source ~/.zshrc

Then migrate. If you previously used OpenClaw, hermes setup will automatically detect the ~/.openclaw directory during first run and ask whether to migrate. You can also do it manually:

hermes claw migrate              # Interactive migration (full preset)
hermes claw migrate --dry-run    # Preview only, no changes made
hermes claw migrate --preset user-data   # Migrate user data only, no keys
hermes claw migrate --overwrite  # Overwrite existing conflicts

The --dry-run option is considerate—it lets you preview changes before executing. --preset user-data suits security-conscious users—transfer only data, not keys; configure keys manually afterward.

Once migration finishes, start the gateway:

hermes gateway      # Start the message gateway

The whole process, from installation to running, can take under ten minutes if smooth.

Noteworthy Security Audit Feature

Hermes Agent also includes an openclaw security audit command that scans gateway configurations for security risks. Considering OpenClaw’s February vulnerabilities, this is clearly a targeted addition.

For migrating users, it’s advisable to run an audit post-migration to ensure no legacy security issues were carried over.

Other Notable Capabilities

Beyond the core learning loop and migration tool, Hermes Agent packs several useful features:

• Built-in cron job scheduler—no extra setup
• 40+ built-in tools, including browser automation and a code execution sandbox
• Supports parallel sub-agents for concurrent execution of complex tasks
• Fully compatible with the agentskills.io open standard—community skill packs can be used directly
• Built on the MCP (Model Context Protocol) standard, ensuring interoperability at the protocol level

The MCP point deserves special mention. As the intelligent agent ecosystem grows more complex, interoperability between frameworks becomes increasingly vital. By building on the MCP standard, Hermes Agent’s generated skills and tool definitions are theoretically reusable across other MCP-compatible frameworks—a forward-looking design decision.

Let’s Cool Down and Acknowledge Some Caveats

After all these advantages, it’s worth some sober thinking.

First, while 28.4k GitHub stars look great, there’s often a huge gap between star count and production readiness. Hermes Agent is still very new; long-term stability, edge-case handling, and large-scale performance still need verification.

Second, “self-evolution” sounds great, but the quality of automatically generated and optimized skills heavily depends on the underlying LLM. Using a weaker model could yield inaccurate skills and introduce errors. The documentation doesn’t address this in depth.

Third, streaming output currently only works in the default chat mode. Other interaction modes are still being adapted. If your use case relies on stream output (like real-time chatbots), be sure it fits your scenario.

Fourth, the one-liner installer uses curl | bash. Convenient, but from a security perspective, it’s always best practice to review the fetched script before executing. Old advice, but always worth repeating.

In Summary

Hermes Agent marks a meaningful step forward—from “tool” to “partner” in intelligent agent frameworks. Its built-in learning loop isn’t a gimmick; it genuinely solves the long-standing “forgetfulness” problem that has driven developers mad for years.

For current OpenClaw users, now’s a great time to evaluate. The one-click migration script minimizes switching costs, and --dry-run lets you preview without risk. Even if you decide not to migrate, it’s worth installing just to experience what it’s like to have an “agent with a memory.”

For developers new to the agent framework world, Hermes Agent’s low deployment barrier and flexible model-switching make it an appealing starting point. A $5 VPS and a single install command—about as low a bar as it gets.

Project link: https://github.com/NousResearch/hermes-agent

---

References:

• Discussion on Hermes Agent One-Click Script Tool Launch — Technical discussion on Hermes Agent deployment and migration in the Linux.do community
• Hermes Agent Open Source Project — Official Nous Research GitHub repository with full documentation and installation guide