Hermes Agent: The Self-Improving Open-Source AI Agent - A Complete Technical Guide & OpenClaw Migration Handbook

Published on April 6, 2026

1. Introduction

In 2026, the landscape of personal AI assistants fundamentally changed. The conversation shifted from “can AI answer my questions?” to “can AI remember what it learned yesterday and do it better tomorrow?” Stateless chatbots - even powerful ones - require users to re-explain context, re-teach preferences, and re-describe workflows session after session. The emerging category of persistent, self-improving agents aims to solve this problem by running continuously on user-controlled infrastructure, accumulating knowledge and capabilities over time.

In late March 2026, Nous Research - the AI research lab known for the Hermes family of fine-tuned LLMs - released Hermes Agent, an open-source (MIT-licensed) autonomous agent framework built around a simple thesis:

An AI agent should learn from completed work and get measurably better the longer it runs.

Hermes Agent enters a competitive space already occupied by OpenClaw (formerly Clawdbot/Moltbot), the viral personal AI assistant created by Peter Steinberger that has accumulated over 349,000 GitHub stars. This guide provides a thorough, balanced examination of Hermes Agent - what it does well, where it falls short, how it compares to OpenClaw feature-by-feature, and how to migrate if you decide to switch.

Disclaimer: Both projects are under active development and evolving rapidly. The information here is accurate as of April 6, 2026, based on primary source documentation from both projects’ official repositories and websites.

2. What Is Hermes Agent?

Hermes Agent is a self-hosted, persistent AI agent that runs on your own server (or a $5 VPS) and connects to your messaging platforms. It is not a coding copilot bound to an IDE, nor a chatbot wrapper around a single API. According to its official documentation:

• It lives on your server - not in a vendor’s cloud. Your data, conversations, and learned skills stay on your infrastructure.
• It remembers everything - persistent memory files (MEMORY.md, USER.md) are injected into every session. Long-term history is searchable via SQLite FTS5 with LLM-powered summarization.
• It auto-generates skills - after successfully completing a complex task, the agent can synthesize the workflow into a reusable skill document following the open agentskills.io standard.
• It reaches you everywhere - a single gateway process connects the agent to Telegram, Discord, Slack, WhatsApp, Signal, Email, SMS (Twilio), Matrix, Mattermost, Home Assistant, DingTalk, Feishu/Lark, WeCom, and the terminal CLI.

Key Differentiators from Traditional Chatbots

3. Core Features & Capabilities

Persistent Memory & Closed Learning Loop

The central design principle. Hermes uses a layered memory architecture:

• MEMORY.md - Environment facts and lessons learned, injected into every system prompt. Kept intentionally concise to force curation over accumulation.
• USER.md - User preferences, communication styles, and relationship context.
• SQLite FTS5 session search - Full-text indexed conversation history with LLM summarization, enabling retrieval of relevant context from weeks or months ago.
• Honcho dialectic user modeling - An optional integration with Honcho (by Plastic Labs) for deeper user preference modeling across sessions. Honcho uses a “peer paradigm” and reasoning models to build high-fidelity representations of user identity, values, and mental states over time.
• Procedural memory (Skills) - Successful workflows are converted into reusable skill documents, forming the agent’s “how-to” knowledge base.
• Pluggable Memory Provider Interface (v0.7.0) - Memory has been transitioned to an extensible plugin system. Users can choose different backends (Honcho, vector stores, custom databases) and register them via the plugin system.

The closed learning loop operates as follows: the agent executes a task → evaluates the outcome → synthesizes a skill document → stores it → retrieves and applies the skill when a similar task recurs. Periodic “nudge” cycles (triggered by heartbeat prompts) trigger memory consolidation, skill refinement, and output cleanup.

Auto-Generated & Community Skills

• The agent creates skills autonomously from experience, stored as Markdown files following the agentskills.io open format. The agentskills.io standard uses a folder structure with a mandatory SKILL.md file containing YAML frontmatter metadata and Markdown instructions. Skills are designed for progressive disclosure: at startup, only the name and description are loaded; full instructions are loaded on demand to minimize token usage.
• 40+ bundled skills covering MLOps, GitHub workflows, research pipelines, and more.
• Community skills can be installed from ClawHub, LobeHub, and GitHub repositories.
• Users can trigger skills via /skills to list all available skills or /<skill-name> to invoke a specific one.

Multi-Platform Gateway

A single gateway process connects the agent to multiple messaging surfaces:

• Telegram, Discord, Slack, WhatsApp, Signal, Email, SMS (via Twilio), Matrix, Mattermost, Home Assistant, DingTalk, Feishu/Lark, WeCom, CLI
• Start a conversation on one platform and continue on another - the agent’s session is tied to an ID, not a specific platform.
• The gateway runs as a systemd service for always-on availability.
• Setup: hermes gateway setup (interactive wizard) → hermes gateway (start) → hermes gateway install (systemd service).
• The agent can also act as an OpenAI-compatible API server, allowing connection from frontends like Open WebUI, LobeChat, or LibreChat.

Natural-Language Cron Scheduling & Unattended Automations

• Schedule recurring tasks using natural language (e.g., “Every morning at 8 AM, summarize my inbox and send it to Telegram”).
• Tasks run unattended through the gateway, even when you are not actively chatting.
• Managed via /cron or the scheduling tools.

Subagents, Parallelization & Python RPC

• The agent can spawn isolated subagents with their own conversation contexts, terminal environments, and Python RPC scripts.
• Subagents run in parallel with zero context cost to the main agent - meaning delegated tasks do not bloat the primary conversation.
• Useful for pipeline-style work: research in one subagent, code generation in another, testing in a third.

Real Sandboxing

Five execution backends with genuine security isolation:

Docker-based sandboxing includes read-only root filesystems, dropped Linux capabilities, and Linux namespace isolation.

40+ Built-In Tools

Including but not limited to:

• Web search and browser automation (with the new Camoufox anti-detection backend in v0.7.0)
• Terminal and filesystem access
• Vision (image analysis) and image generation
• Text-to-speech (TTS)
• Code execution in sandboxed environments
• Subagent delegation and parallel task management
• Task planning and cron scheduling
• Multi-model reasoning (query multiple LLMs and compare)
• Memory read/write/search tools

Research Tooling

A distinguishing feature from Nous Research’s ML research background:

• Batch trajectory generation - Run the agent against problem sets with parallel workers and checkpointing.
• Atropos RL integration - Connect to Tinker-Atropos for reinforcement learning training loops. Atropos acts as a trajectory API server coordinating environment interactions and computing advantages, while the Tinker training service handles model weights, LoRA training, and optimizer steps. This enables GRPO (Group Relative Policy Optimization) training with LoRA adapters directly through the agent’s tool interface.
• ShareGPT export - Export trajectories with compression for fine-tuning datasets.

Supported Models

Hermes Agent is model-agnostic. Switch providers with hermes model - no code changes:

• Nous Portal - OAuth-based access to Nous-hosted models
• OpenRouter - 200+ models via API key
• z.ai/GLM, Kimi/Moonshot, MiniMax
• OpenAI, Anthropic, or any OpenAI-compatible endpoint (including locally hosted via Ollama, vLLM, etc.)

4. Architecture & Technical Deep Dive

How the Closed Learning Loop Works

┌─────────────────────────────────────────────┐
│              User Request                   │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│  1. Skill Retrieval                         │
│     Query existing skill documents          │
│     for relevant procedures                 │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│  2. Task Execution                          │
│     Execute using tools, subagents,         │
│     terminal, browser, etc.                 │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│  3. Outcome Evaluation                      │
│     Assess success/failure of task          │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│  4. Skill Synthesis                         │
│     Convert successful workflow into        │
│     reusable agentskills.io document        │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│  5. Memory Consolidation                    │
│     Update MEMORY.md, USER.md               │
│     Index in SQLite FTS5                    │
└─────────────────────────────────────────────┘

Periodic nudges (heartbeat-triggered maintenance cycles) run between sessions to consolidate memories, clean up artifacts, and refine or merge skills. This creates a compounding effect - the agent improves with use, not just during active interaction.

Skill System & Memory Stack

Skills are Markdown files that describe procedures, tool invocations, and expected outcomes. They follow the open agentskills.io specification, making them portable between agents and shareable with the community. The specification is complementary to the Model Context Protocol (MCP) - while MCP focuses on how an agent connects to external tools and data, Agent Skills teach the agent how to use those tools and perform specific tasks effectively.

Memory layers:

1. Prompt-level (MEMORY.md + USER.md) → Always injected. Concise. Curated.
2. Session search (SQLite FTS5 + LLM summarization) → Searchable history across all past conversations.
3. Procedural (Skill documents) → “How-to” knowledge. The agent’s learned methods.
4. Honcho user modeling → Dialectic modeling of user preferences and personality (optional, via Honcho). Honcho treats all entities as “peers” and uses continual learning with reasoning models to derive explicit/deductive conclusions about user identity and values.

Runtime Environments & Security

The agent supports five runtime backends (local, Docker, SSH, Singularity, Modal). Docker-based sandboxing enforces:

• Read-only root filesystem
• Dropped Linux capabilities (e.g., CAP_NET_RAW, CAP_SYS_ADMIN)
• Linux namespace isolation (PID, network, mount)

v0.7.0 security additions:

• Secret exfiltration blocking - scans browser URLs and LLM responses for credential patterns (base64, URL-encoded secrets, prompt injection attempts)
• Expanded credential directory redaction (.docker, .azure, .config/gh)
• Sandbox output redaction for execute_code
• Supply chain hardening - dependency management improvements, removal of compromised packages, and updated CI workflows

CLI + Gateway Design

┌─────────────────────────────────────────────┐
│           Terminal (hermes CLI)             │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│           Hermes Agent Core                 │
│     (Python 3.11, uv-managed venv)          │
│                                             │
│  ┌──────────┐      ┌──────────┐             │
│  │  Memory  │      │  Skills  │             │
│  │  System  │      │  System  │             │
│  └──────────┘      └──────────┘             │
│  ┌──────────┐      ┌──────────┐             │
│  │ 40+ Tools│      │ Subagents│             │
│  └──────────┘      └──────────┘             │
└──────────────────┬──────────────────────────┘
                   │
                   ▼
┌─────────────────────────────────────────────┐
│          Messaging Gateway                  │
│    (systemd service, always-on)             │
│                                             │
│  Telegram │ Discord │ Slack │ WhatsApp      │
│  Signal   │ Email   │ SMS   │ Matrix        │
│  Mattermost │ Home Assistant │ DingTalk     │
│  Feishu/Lark │ WeCom │ CLI                  │
└─────────────────────────────────────────────┘

v0.7.0 (“The Resilience Release”) - Key Additions

Released April 3, 2026, v0.7.0 brought significant improvements across stability, security, and extensibility:

• Camoufox Anti-Detection Browser - A new local browser backend using Camoufox for stealth web research and scraping with reduced risk of anti-bot blocking. Supports persistent sessions and VNC URL discovery for visual debugging.
• Pluggable Memory Provider Interface - Memory backends are now extensible via a plugin system (Honcho, vector stores, custom databases).
• Same-Provider Credential Pools - Configure multiple API keys for the same provider with automatic “least-used” rotation to improve reliability and avoid rate limits.
• Inline Diff Previews - File write and patch operations display inline diffs in the tool activity feed, allowing visual confirmation of changes.
• Gateway Hardening - Fixes for race conditions, flood control, stuck sessions, and approval routing.
• ACP (Agent Client Protocol) / Client-Provided MCP Servers - Editor integrations (VS Code, Zed, JetBrains) can register MCP servers that Hermes automatically picks up as tools.
• API Server Session Continuity - Real-time streaming of tool progress with persistent sessions across requests via session headers.
• New slash commands - /yolo (toggle dangerous command approvals), /btw (ephemeral side questions without impacting conversation context), /profile (show active profile info).

Notable Directory Structure

hermes-agent/
├── agent/          # Core agent logic
├── tools/          # Built-in tool implementations
├── skills/         # Bundled skill documents
├── optional-skills/# Additional skills
├── gateway/        # Messaging gateway (Telegram, Discord, etc.)
├── cron/           # Scheduling system
├── environments/   # Sandbox backend definitions
├── hermes_cli/     # CLI commands and subcommands
├── plugins/        # Plugin system
├── docker/         # Docker configurations
├── docs/           # Documentation source
├── scripts/        # Install and setup scripts
├── tests/          # Test suite
└── tinker-atropos/ # RL integration (git submodule)

5. Detailed Comparison: Hermes Agent vs. OpenClaw

Feature Comparison Table

Narrative Comparison

Where Hermes Agent Excels

1. Self-improvement is a real, structural feature - not marketing language. The closed learning loop, periodic nudges, and automatic skill synthesis are baked into the architecture. OpenClaw’s agent can write skills, but there is no equivalent automated feedback cycle.

2. Memory architecture is deeper - the layered stack (prompt-level files → SQLite FTS5 → procedural skills → pluggable memory providers → Honcho user modeling) provides richer long-term context than OpenClaw’s session-based memory. The v0.7.0 pluggable memory interface makes this even more extensible.

3. Sandbox variety - five distinct execution backends (including Singularity for HPC and Modal for serverless GPU) give users fine-grained control over isolation and cost.

4. Research tooling - trajectory generation, Atropos RL integration (with GRPO training via LoRA adapters), and ShareGPT export are features aimed at ML researchers and agent-training workflows. No competitor offers this natively.

5. Security posture - as of April 2026, Hermes has no public CVEs. OpenClaw has faced significant security incidents, including CVE-2026-25253 - a high-severity (CVSS 8.8) remote code execution vulnerability where improper validation of the gatewayUrl parameter allowed attackers to steal authentication tokens via crafted links, bypass localhost protections, and execute arbitrary commands. The vulnerability affected all versions prior to 2026.1.29. Hermes’s sandbox-first design, v0.7.0 secret exfiltration blocking, and supply chain hardening reflect a security-conscious approach.

6. Lightweight runtime - Python + uv makes for a minimal footprint. It can run on a $5 VPS.

7. Editor integration - the v0.7.0 ACP (Agent Client Protocol) allows VS Code, Zed, and JetBrains extensions to register MCP servers that Hermes automatically discovers and uses as tools.

Where OpenClaw Excels

1. Channel breadth is unmatched - with 20+ messaging channels (including iMessage, Microsoft Teams, LINE, IRC, Nostr, WeChat, Google Chat), OpenClaw is the clear leader for multi-platform reach. Hermes supports 14+ channels, covering the most common platforms but missing some niche ones like iMessage and IRC.

2. Native companion apps - macOS menu bar app, iOS app, and Android app provide a polished, platform-native experience. Hermes is CLI-based with an OpenAI-compatible API server for connecting UI frontends.

3. Live Canvas (A2UI) - an agent-driven visual workspace unique to OpenClaw and not available in Hermes.

4. Voice Wake and Talk Mode - continuous voice interaction on macOS/iOS/Android with wake word support. Hermes has TTS and voice message transcription but lacks real-time voice interaction with wake word detection.

5. Community and ecosystem - 349,000 stars, 70,000 forks, 27,000+ commits, and a mature ClawHub marketplace. The OpenClaw community is significantly larger and more active.

6. Windows support - OpenClaw runs natively on Windows via Node.js. Hermes requires WSL2.

7. Battle-tested at scale - with ~27,500 commits and continuous releases, OpenClaw has been through more real-world stress testing. Hermes, at ~3,300 commits and 7 releases, is comparatively younger.

When to Choose Each

• Choose Hermes Agent if: You prioritize long-term learning and continuous improvement; you want your agent to get better at your specific workflows over weeks and months; you need research/ML training tooling; you want strong sandbox isolation options; you prefer Python-based tooling; you want editor integration via ACP/MCP; or you are security-conscious and want a smaller attack surface.

• Choose OpenClaw if: You need broad messaging platform coverage (especially iMessage, Teams, IRC, or LINE); you want native mobile apps and live voice interaction with wake words; you prefer a larger community and skill marketplace; you need the Live Canvas for visual workflows; or you are already invested in the Node.js ecosystem.

• Use both: Some power users deploy both - OpenClaw for its superior multi-channel orchestration and native apps, and Hermes for research-heavy, learning-intensive tasks. The hermes claw migrate command makes bridging the two straightforward.

6. Migration from OpenClaw - Step-by-Step Handbook

Hermes Agent includes a first-class migration path for OpenClaw users. The hermes claw migrate command can import your persona, memories, skills, API keys, messaging settings, and workspace instructions.

Automatic Detection During Setup

When you run hermes setup for the first time, the setup wizard automatically detects an existing ~/.openclaw directory and offers to migrate before configuration begins.

hermes setup
# If ~/.openclaw is detected, you'll be prompted:
# "OpenClaw installation detected. Would you like to migrate? [Y/n]"

Manual Migration Commands

If you have already installed Hermes and want to migrate later:

# Full interactive migration (recommended)
hermes claw migrate

# Preview what would be migrated without making changes
hermes claw migrate --dry-run

# Migrate only user data (no secrets/API keys)
hermes claw migrate --preset user-data

# Overwrite any existing Hermes files that conflict
hermes claw migrate --overwrite

# See all available options
hermes claw migrate --help

What Gets Migrated

Interactive Migration Skill

For a guided, agent-assisted migration experience, use the built-in openclaw-migration skill:

hermes
# Then in the chat:
/openclaw-migration

This skill walks you through the migration interactively, showing dry-run previews before making changes.

Post-Migration Checklist

1. Verify persona - Run hermes and confirm the agent’s personality matches your expectations.
2. Check API keys - Run hermes config set or check your configuration to ensure API keys transferred correctly.
3. Test messaging - Start the gateway (hermes gateway) and send a test message from each connected platform.
4. Review imported skills - Check ~/.hermes/skills/openclaw-imports/ to ensure your custom skills look correct.
5. Run diagnostics - Execute hermes doctor to surface any configuration issues.
6. Update memory - The agent’s memory files may need minor adjustments for Hermes’s format. Review MEMORY.md and USER.md in your Hermes config directory.

Known Gotchas

• OpenClaw skills are TypeScript/Node.js - while Hermes imports skill definitions (the Markdown/instruction layer), any skills with inline TypeScript code will need to be rewritten in Python or as tool invocations.
• Channel differences - if you use iMessage, Teams, IRC, or other channels only supported by OpenClaw, those configurations will not migrate (Hermes does not support those channels).
• --overwrite is destructive - if you have already customized your Hermes configuration, the --overwrite flag will replace existing files. Use --dry-run first.
• Workspace instructions require --workspace-target - AGENTS.md files are not migrated by default; you must explicitly pass this flag.

7. Installation & Quickstart

One-Liner Installer

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

This handles everything: installs uv, Python 3.11, clones the repository, sets up dependencies, and adds the hermes command to your PATH. No prerequisites except git. No sudo required.

Supported platforms: Linux, macOS, WSL2.

After installation, reload your shell:

source ~/.bashrc   # or: source ~/.zshrc

Setup Wizard

hermes setup

The interactive setup wizard walks you through:

1. Model provider selection (Nous Portal, OpenRouter, or custom endpoint)
2. API key configuration
3. Memory and personality setup
4. Gateway configuration (optional)
5. OpenClaw migration (if ~/.openclaw is detected)

Model Selection

hermes model

Interactive picker for model provider and specific model. Switch at any time - no code changes, no restarts needed.

Gateway Setup (Multi-Platform)

# Interactive gateway setup wizard
hermes gateway setup

# Start the messaging gateway
hermes gateway

# Install as a systemd service (always-on)
hermes gateway install

The wizard walks you through connecting Telegram, Discord, Slack, WhatsApp, Matrix, or any of the other supported platforms. The gateway runs as a systemd service.

Start Chatting

hermes

Full interactive CLI with tools, memory, and skills. Use /new to start a new conversation, /skills to list available skills, /model to switch models mid-conversation, /yolo to toggle dangerous command approvals, /btw for ephemeral side questions, and Ctrl+C to interrupt.

Updating

hermes update

Pulls the latest changes from the repository and reinstalls dependencies.

Diagnostics

hermes doctor

Diagnoses common issues with configuration, dependencies, and connectivity.

Windows (WSL2) Notes

Native Windows is not supported. Install WSL2 and run all commands from the WSL2 terminal:

# From PowerShell (install WSL2 first)
wsl --install

# Then from the WSL2 terminal
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

8. Real-World Daily Use Cases

The self-improving nature of Hermes shines in workflows that recur and evolve. Here are concrete examples drawn from the community:

1. Automated Research Pipelines

Ask the agent to research a topic, synthesize findings, and produce a report. The first time takes extensive back-and-forth. By the third time, the agent has generated a research-pipeline skill that remembers your preferred sources, citation format, and output structure. Subsequent research requests execute faster and more consistently.

2. DevOps Monitoring & Incident Response

Configure a cron job: “Every 30 minutes, check the health of my staging server and alert me on Telegram if anything is down.” The agent learns the specific health check commands for your stack, builds skills around interpreting log output, and improves its alert formatting over time based on your feedback.

3. Personal Knowledge Management

Use the agent as a “second brain” - tell it things throughout the day via Telegram or Discord. It stores information in its memory system and can retrieve it later. “What was the name of that restaurant I mentioned last Tuesday?” Unlike a simple note app, the agent cross-references context from different conversations and platforms.

4. Code Review & Refactoring Assistance

Point the agent at a codebase and ask for reviews. It uses subagents to parallelize - one reviews architecture, another checks for security issues, a third runs the test suite. Skills accumulate for your specific stack’s patterns and common pitfalls.

5. Content Creation Pipeline

“Draft a blog post about X, check the facts, generate a header image, and format it in Markdown.” The agent learns your writing style (via USER.md), preferred image generation prompts, and formatting conventions. Each subsequent content request benefits from the accumulated preferences.

6. Email & Calendar Triage

Connect the agent to your email (via gateway) and ask it to triage your inbox every morning. It learns which senders are high-priority, which newsletters to summarize vs. skip, and how you prefer briefings formatted.

7. Multi-Model Reasoning for Complex Decisions

For decisions requiring multiple perspectives, the agent can query several LLMs in parallel (e.g., Claude for analysis, GPT-4 for creative options, Gemini for fact-checking) and synthesize the results. Skills remember which models performed best for different task types.

8. ML Experiment Management

For researchers: use the trajectory generation and Atropos RL integration to run agent evaluations at scale. Generate ShareGPT-format datasets for fine-tuning. The research tooling is a genuine differentiator - not available in competing agent frameworks.

9. Smart Home Automation

Connect Hermes to Home Assistant via the gateway and control IoT devices, automate routines, and build context-aware home management skills. The agent learns your preferences over time - adjusting lighting, temperature, and device schedules based on accumulated observations.

9. Conclusion & Recommendation

A Balanced Assessment

Hermes Agent introduces a genuinely novel architectural concept to the personal AI agent space: the automated, closed learning loop that transforms completed work into reusable procedural knowledge. This is not a superficial feature - it is designed into the memory stack, the skill system, and the agent’s periodic maintenance cycles. The v0.7.0 release (“The Resilience Release”) demonstrates the project’s rapid maturation with pluggable memory providers, editor integration via ACP, anti-detection browsing, and significant security hardening.

However, it is a younger project (v0.7.0, ~3,300 commits) entering a space dominated by OpenClaw (~27,500 commits, 349k stars). OpenClaw’s advantages in channel breadth (20+ vs. 14+), native apps (macOS/iOS/Android), voice interaction with wake words, community size, and overall maturity are substantial.

Who Should Use Hermes Agent Today

• ML researchers and developers who want built-in trajectory generation and RL training integration with GRPO and LoRA support.
• Users who prioritize self-improvement - if you find yourself repeatedly re-teaching your AI assistant the same workflows, Hermes’s learning loop addresses this directly.
• Security-conscious users - Hermes’s sandbox-first design and clean security track record (no public CVEs) make it appealing for environments where security is non-negotiable.
• OpenClaw users hitting friction - if you use OpenClaw and feel the agent isn’t “learning” enough between sessions, Hermes’s memory architecture may be the upgrade you need. The migration path (hermes claw migrate) makes switching low-risk.
• Developers using VS Code, Zed, or JetBrains - the ACP integration enables seamless editor-to-agent communication via MCP servers.

Who Should Stay on OpenClaw

• Users who rely on iMessage, Teams, LINE, IRC, Nostr, WeChat, or any of the channels only OpenClaw supports.
• Users who depend on the macOS/iOS/Android native apps, Live Canvas, or Voice Wake.
• Users who want the largest possible community and skill marketplace.
• Teams and multi-user setups where OpenClaw’s multi-agent routing and group channel management are essential.

Getting Started

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

• GitHub: github.com/NousResearch/hermes-agent
• Website: hermes-agent.nousresearch.com
• Docs: hermes-agent.nousresearch.com/docs
• Discord: discord.gg/NousResearch

Sources & References

All information in this guide was sourced from the following primary sources, accessed on April 6, 2026:

1. Hermes Agent Official Website - hermes-agent.nousresearch.com
2. Hermes Agent GitHub Repository - github.com/NousResearch/hermes-agent (~26k stars, 3.5k forks, 3,316 commits, MIT license)
3. Hermes Agent v0.7.0 Release Notes - github.com/NousResearch/hermes-agent/releases/tag/v2026.4.3 (April 3, 2026, “The Resilience Release”)
4. Hermes Agent Documentation - hermes-agent.nousresearch.com/docs
5. OpenClaw Official Website - openclaw.ai
6. OpenClaw GitHub Repository - github.com/openclaw/openclaw (349k stars, 70k forks, 27,458 commits, MIT license)
7. OpenClaw Documentation - docs.openclaw.ai
8. agentskills.io - agentskills.io (open skill format specification)
9. Honcho (Plastic Labs) - github.com/plastic-labs/honcho
10. CVE-2026-25253 - NIST NVD (OpenClaw RCE vulnerability, CVSS 8.8, fixed in v2026.1.29)

This guide is not affiliated with Nous Research or OpenClaw. Both projects are independent open-source efforts under the MIT license. Evaluate both on their merits for your specific use case.