Agent Installs Agent: Using OpenClaw to Install Hermes, and Testing Self-Evolution Along the Way

9 min readApr 16, 2026

TL;DR: Used OpenClaw to fully control a remote VM — from provisioning with Terraform to installing and configuring Hermes Agent — and triggered self-evolution in the process, generating a high-quality Skill.

1. Background

A few days ago, a friend recommended Hermes Agent to me — an open-source personal AI assistant from Nous Research. He specifically highlighted one feature: self-evolution. The agent can automatically create Skills after completing complex tasks, iteratively optimizing them over time to form a closed learning loop.

That concept immediately resonated with something I’ve been doing myself.

I’ve already implemented something similar across multiple AI tools using a skill-creator skill — whether it’s OpenClaw as a personal assistant or OpenCode as a coding agent. The pattern is the same: the user actively triggers Skill creation and refinement, iterating through usage to gradually raise the agent’s capability ceiling. I’ve also studied HyperAgents, exploring what agent self-evolution could look like.

So when my friend said “Hermes does this automatically,” my first reaction wasn’t excitement — it was curiosity: Which approach is more effective, automated or manual? How big is the gap between Hermes’s design philosophy and what I’m already doing?

I decided to try it. But how? Use my AI agent to install another AI agent — that’s the right way to do it.

2. Hermes vs OpenClaw: Is It Worth Installing?

Before diving in, let’s do some homework.

Hermes Agent and OpenClaw occupy nearly identical niches — both are self-hosted personal AI assistants, both support multi-platform access via Telegram/Discord/etc., both have Skill systems and cron scheduling. The key differences:

The most fundamental difference is in how each treats Skills:

OpenClaw’s Skills are human-written and static — you (or the skill-creator) write a SKILL.md, and the agent reads and executes it. Skill quality depends on human investment.

Hermes’s Skills are agent-written and dynamic — after completing a complex task, the agent analyzes its own execution path, distills it into a reusable workflow, writes it to ~/.hermes/skills/, and calls it directly next time a similar task comes up — continuously patching and improving through use.

This design philosophy is closer to how humans accumulate experience — not memorizing textbooks, but extracting methodology from hands-on practice.

Worth trying.

3. Installation: A Chain of Agent Handoffs

I decided to install Hermes the same way I deployed OpenClaw — no manual commands, let the agent handle everything.

The full chain:

Specifically:

Send a message on Telegram from my phone
Local OpenCode receives the instruction, provisions a new VM on the cloud using Terraform
Cloud-hosted OpenClaw (Echo, my personal assistant) receives the instruction, SSH into the newly created VM
Echo takes full control of the VM, completing Hermes installation and configuration

Throughout this process, I never opened a terminal, never SSH’d in, never manually executed a single command. This isn’t a gimmick — it’s a real use case of AI agents as infrastructure automation tools. And this pipeline wasn’t built for this article; it’s how I deploy new services day-to-day.

4. Installation: What Went Wrong

After Echo connected to the VM via SSH, it began the installation. Hermes provides a one-liner install script:

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

Sounds simple. In practice, three issues came up.

Issue 1: Install Script Got Killed

The script was killed midway through. The install script by default installs Playwright Chromium — Hermes’s browser tool dependency for web automation (screenshots, clicks, scraping, etc.). The full Chromium package is ~170MB; the download timed out and was forcibly terminated.

This isn’t a required dependency. If you don’t need browser automation, this step can be skipped entirely. The script itself has fallback handling — a failed Playwright install only disables browser tools, it doesn’t affect core functionality.

Fortunately, the codebase had already been downloaded. A manual PATH fix was enough:

echo 'export PATH="$HOME/.hermes/hermes-agent/venv/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc
hermes --version  # Hermes Agent v0.9.0

Issue 2: TUI Broken in Non-Interactive SSH

When running hermes model to select a model, the TUI's arrow keys were completely unresponsive — Echo was connected via non-interactive SSH, and the terminal didn't support standard ANSI control sequences, so the cursor couldn't move.

Workaround: edit the config file directly.

# In ~/.hermes/config.yaml
model:
  provider: "copilot"
  default: "claude-sonnet-4.6"

GitHub Copilot’s OAuth authorization requires completing a device code flow in a browser — this step genuinely requires human intervention. Open https://github.com/login/device, enter the 6-digit code Echo retrieved, authorize, and continue.

Issue 3: Wrong SOUL.md Path

When configuring the persona file, I asked the Hermes bot to write SOUL.md. It wrote the file to ~/.hermes/memories/SOUL.md — seemingly reasonable, but Hermes actually reads the persona file from ~/.hermes/SOUL.md.

cp ~/.hermes/memories/SOUL.md ~/.hermes/SOUL.md
# hermes doctor confirms:
# ✓ ~/.hermes/SOUL.md exists (persona configured)

None of these three issues were serious, and the workarounds were all straightforward. But if you’re installing for the first time, hitting Issue 1 could easily make you think the whole installation failed.

5. Configuration Checklist

After installation, four things needed to be configured before everything worked properly.

GitHub Copilot Authorization

Hermes supports multiple model providers (OpenRouter, Anthropic, GitHub Copilot, DeepSeek, Gemini, etc.). I chose to reuse my existing GitHub Copilot subscription.

hermes model
# Select GitHub Copilot
# Option 1: Login with GitHub (OAuth device code flow)

Open https://github.com/login/device in a browser, enter the 6-digit code displayed in the terminal, and the token is automatically saved to ~/.hermes/auth.json after authorization.

SOUL.md: Migrating the “Soul”

Hermes supports a custom agent persona via ~/.hermes/SOUL.md — exactly the same design as OpenClaw. I migrated my OpenClaw SOUL.md content directly, keeping consistent language preferences and behavioral guidelines: always reply in Chinese, no filler, have opinions.

USER.md works the same way: write user background, goals, Obsidian vault path, etc. to ~/.hermes/memories/USER.md.

Telegram Gateway

# Write to ~/.hermes/.env
TELEGRAM_BOT_TOKEN=<your bot token>
TELEGRAM_ALLOWED_USERS=<your Telegram user ID>
TELEGRAM_HOME_CHANNEL=<your Telegram user ID>

# Register and start the systemd service
hermes gateway install
hermes gateway start

The installer automatically enables systemd linger, ensuring the gateway auto-starts after VM reboots and stays alive after SSH disconnects.

hermes gateway status
# ✓ User gateway service is running
# ✓ Systemd linger is enabled (service survives logout)

Web Search: Tavily

Hermes’s web tools support four providers: Exa, Tavily, Firecrawl, and Parallel. Without any API key configured, web search is unavailable. I chose Tavily — designed specifically for AI agents, with 1,000 free requests/month and easy signup.

# Write to ~/.hermes/.env
TAVILY_API_KEY=<your key>

hermes gateway restart

hermes doctor showed all core features ready: Python environment, SOUL.md, USER.md, Gateway service, systemd linger, terminal/file/web/vision/skills/browser/cronjob tools all operational. Hermes is live.

6. Self-Evolution: Expectations vs. Reality

This was the core motivation for installing Hermes, and the thing I most wanted to verify.

Trigger Conditions

Based on the docs and source code, self-evolution triggers when:

The main agent completes a complex task involving 5+ tool calls
The user corrects the agent’s approach
The agent took a wrong path but found the right one
A non-obvious workflow was discovered

The config has a nudge setting that controls reminder frequency:

skills:
  creation_nudge_interval: 15  # Default: remind agent to consider creating a Skill every 15 accumulated tool calls

To accelerate testing, I temporarily lowered it to 5:

skills:
  creation_nudge_interval: 5

Two things worth noting: the nudge counter accumulates within a single session and doesn’t persist across sessions. And per the source code (L1131, L8075), only tool calls in the main agent loop count — subagent calls don’t.

Results

In the same session, I had Hermes execute similar tasks consecutively (searching for latest versions of cloud-native components, compiling changelog comparison tables). After accumulating past the threshold, this appeared immediately after task completion:

💾 Skill 'tech-version-changelog-comparison' created.

The generated Skill exceeded expectations — not just a list of operational steps, but including:

Core workflow: Parallel search goal template with key constraints (exclude RC versions, cross-validate sources)
Known issues and lessons learned: Analysis of why version inconsistencies occur in searches, with solutions
Pattern of increasing depth over iterations: “The first search should focus on breaking changes”
Complete Markdown template: Table structure, naming conventions, Chinese summary framework

This Skill isn’t recording “how to use the tools” — it’s preserving hard-won lessons and distilled methodology. The full Skill content is published as a GitHub Gist for anyone to reuse or reference.

The Fundamental Difference Between the Two Approaches

The two approaches aren’t mutually exclusive. I use skill-creator in OpenClaw and OpenCode to actively preserve clearly-defined workflows. Hermes’s automation is better suited for things you know are worth accumulating but are too lazy to write manually — use it enough, and it’ll summarize on its own.

7. Summary

Using an AI agent to install another AI agent is itself an interesting experiment.

On installation experience, Hermes had more rough edges than OpenClaw: Playwright download timeout, TUI failure in non-interactive SSH, wrong SOUL.md path. None of these are serious issues, but without an agent to help debug, manual troubleshooting would take a while.

On feature coverage, the two are highly overlapping. Platform support, Skill system, cron scheduling, memory mechanisms — core capabilities are largely aligned. If you just want a personal assistant you can use on Telegram, the difference between the two is small.

The only meaningful difference is: the Skill lifecycle. OpenClaw’s Skills are human-written and static. Hermes’s Skills are written by the agent from real work, and they iterate. The tech-version-changelog-comparison Skill generated in this test didn't just record operational steps — it preserved the pitfalls encountered, data source gotchas, and the pattern of increasing search depth over iterations. That's a quality that's hard to achieve writing Skills manually.

Of course, this feature has a hidden prerequisite: you actually have to keep using it. The nudge counter doesn’t persist across sessions, and subagent tool calls don’t count toward the main agent’s total (source L1131, L8075) — short-term experimentation is unlikely to show results; you need enough complex tasks accumulated within the same session.

The two tools aren’t mutually exclusive. My approach: keep using OpenClaw and OpenCode with skill-creator for deliberately capturing known workflows; run Hermes on a separate VM as a complement, handling tasks that “I do repeatedly but am too lazy to manually write Skills for” — let it grow on its own.

One more feature worth watching that didn’t come up in this article: Honcho user modeling. Hermes optionally integrates the Honcho framework, which continuously infers the user’s mental model and cognitive preferences through conversation, building a dynamic user profile that gets smarter over time — far deeper than a static USER.md. This is also a feature that needs extended use to show its value.

Self-evolution + Honcho user modeling — both features need time to mature. A long-term usage report on Hermes is coming. Stay tuned.

Cover photo from Pexels, photographer: Google DeepMind, used under the Pexels free license.