
Hermes Agent and OpenClaw are both self-hosted, run on MIT licenses, and want to be your always-on AI assistant. They are built on fundamentally different ideas about what that means, and that difference is what decides which one belongs on your server.
I deployed both agents, ran them through setup, connected messaging platforms, tested their skill systems, and pushed at their security defaults.
This is what I found after running both side by side for the same tasks.
What is OpenClaw?

OpenClaw is an open-source personal AI agent platform that runs on your machine, connects to the chat apps you already use, and keeps your data off anyone else’s servers.
The founding premise is in the slogan: “Your assistant. Your machine. Your rules.” OpenClaw is built around a central Gateway daemon, a long-running Node.js server that owns all your messaging connections in one place.
WhatsApp, Telegram, Discord, Slack, Signal, and iMessage all connect through this single process. The agent reaches them all from there.
Architecture at a glance:
- Gateway daemon: Node.js server that owns every channel connection. One process, all platforms.
- Memory: Append-only JSON session files plus SQLite with vector search, stored in ~/.openclaw/
- Skill system: Community-installed plugins and conversational skill creation through ClawHub
- Agent runtime: Uses Pi Agent Core, with session-based trust tiers governing what each channel can do
- Canvas and A2UI: A separate server where the agent can generate and serve interactive HTML interfaces
What is Hermes Agent?

Hermes Agent is an open-source autonomous AI agent built by Nous Research and released in February 2026. The MIT-licensed project describes itself as “the AI agent that grows with you.”
Its design premise is different from OpenClaw’s at every level. Rather than building the best gateway between you and your messaging apps, Hermes is built around a self-improving learning loop where the agent writes and refines its own skills as it works.
It ships with 97 bundled skills across 28 categories, covering MLOps, GitHub workflows, research, note-taking, red teaming, smart home control, media, and more.

When Hermes solves a complex problem, it can write a skill document encoding that approach so it never needs to reconstruct the solution. Those skills follow the agentskills.io open standard, making them portable across agents that support the same format.
Architecture at a glance:
- Single gateway process: One hermes gateway command handles all platforms simultaneously
- Memory: Stored in ~/.hermes/ with skills, session history, and user profiles persisting across restarts
- Skill system: 97 bundled skills, auto-creation after 5+ tool calls on the same pattern, plus Skills Hub at agentskills.io
- Execution backends: 7 options (local, Docker, SSH, Modal, Singularity, Daytona, Vercel)
- Security: Tirith scanner runs before every command execution, fail-closed by default
OpenClaw vs Hermes Agent: Direct Comparison
| Hermes Agent | OpenClaw | |
| Built by | Nous Research | Peter Steinberger + community |
| Architecture | Agent-first: self-improving learning loop | Gateway-first: messaging hub |
| Messaging platforms | 16+ (Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Teams, iMessage, Email, SMS, WeChat, DingTalk, and more) | WhatsApp, Telegram, Discord, Slack, Signal, iMessage, WebChat |
| Bundled skills | 97 across 28 categories | Community-driven; fewer bundled |
| Skill auto-creation | Yes. Auto-creates after 5+ tool calls on same pattern | Partial. Creates via conversation when asked |
| Skill marketplace | Skills Hub + agentskills.io | ClawHub |
| Execution backends | 7 (local, Docker, SSH, Modal, Singularity, Daytona, Vercel) | Docker, SSH, OpenShell |
| Security scanner | Tirith (fail-closed: blocks on scanner error) | Session-based trust tiers |
| Memory storage | ~/.hermes/ (skills, sessions, user profiles) | ~/.openclaw/ (JSON sessions + SQLite + vectors) |
| LLM providers | 200+ via OpenRouter, Nous Portal OAuth, local vLLM, any OpenAI-compatible endpoint | Anthropic, OpenAI, Google, Nexos AI Credits, Ollama |
| No-terminal setup path | No | Yes (Managed OpenClaw on Hostinger) |
| Hostinger starting price | $6.49/mo (KVM 1, promotional) | $5.99/mo (Managed, promotional) |
| License | MIT | MIT |
1. Cost
Both agents are MIT-licensed and free to run. What you pay is the VPS infrastructure and your LLM provider. I tested both on Hostinger, running Hermes Agent VPS and OpenClaw VPS separately and tracking every cost.
VPS Infrastructure on Hostinger

Hermes Agent runs on any of four Hostinger KVM plans. OpenClaw on Hostinger comes in two forms: Managed (no terminal, Nexos AI Credits included) and VPS (full root access, your own API keys).

Here is how the entry points compare:
| Hermes Agent (Hostinger) | OpenClaw (Hostinger) | |
| Cheapest entry | KVM 1 from $6.49/mo (promo, 24-month) | Managed from $5.99/mo (promo, 24-month) |
| Renewal rate | KVM 1 renews at $11.99/mo | Managed renews at $11.99/mo |
| Recommended tier | KVM 2 ($8.99/mo promo) for most workloads | Managed or VPS ($8.99/mo promo) |
| Hardware (mid-tier) | 2 vCPU, 8 GB RAM, 100 GB NVMe, 8 TB bandwidth | 2 vCPU, 8 GB RAM, 100 GB NVMe, 8 TB bandwidth |
| Backups | Free weekly backups included | Free weekly backups included |
| AI credits included | No. Connect your own provider. | Yes, on Managed plan (Nexos AI Credits) |
The AI Credits Cost
This is where the two agents split most noticeably on total monthly cost. Hermes points you to your own API key or an OAuth session with a provider. OpenClaw’s Managed plan on Hostinger includes Nexos AI Credits pre-wired at checkout.
I tracked exact costs across an extended OpenClaw session: 92 messages covering web searches, code generation, file operations, and system monitoring came to $0.45 total via Nexos. A shorter 38-message session covering the same task types cost $0.26. That puts the per-message rate at just under half a cent.
Here is what different usage levels actually cost on Nexos AI Credits:
| Usage level | Messages/month | AI credit cost | Break-even vs. $20 sub |
| Light | ~100 | ~$0.68 | You’d need 2,900 msgs to hit $20 |
| Medium | ~500 | ~$3.40 | Still well under $20 |
| Heavy | ~2,000 | ~$13.60 | Approaching parity with one subscription |
Hermes on your own API key is cheaper per token if you use OpenRouter or direct provider access. The trade-off is setup time and managing multiple accounts. If you already have a Claude Max or OpenAI subscription, connecting it to Hermes means you are not paying for AI twice.
| Nexos AI Credits (OpenClaw Managed) | Own API keys (Hermes or OpenClaw VPS) | |
| Setup time | Zero. Works on deployment. | 15–20 minutes to configure accounts and keys |
| Cost per token | ~117% of direct API rate | Direct provider pricing |
| Default model | Gemini Flash; Claude and GPT-4o available | Your choice across 200+ models via OpenRouter |
| Account management | One bill for VPS and AI | Separate provider accounts and billing |
| Best for | Light to medium use, users who want zero API config | Heavy use or users with existing subscriptions |
Tip: If you already own a Hostinger VPS from another project, you do not need to buy a new server for either agent. In hPanel, click Manage next to your VPS server, then go to Change OS, Change OS, search for the agent you want, and deploy from there. The existing hardware runs the container.

2. Getting Started
Setup time and complexity are where these two agents diverge the most sharply. The gap is not marginal.
| Hermes Agent | OpenClaw (Managed) | |
| Estimated setup time | ~35 minutes | ~25 minutes |
| Terminal required | Yes | No |
| OAuth step | Yes. Manual URL copy and code paste. | No |
| Token to save | One-time auth token, shown once in yellow | Gateway token, buried in Docker Manager |
| First response | After terminal setup wizard completes | After channel connection from web UI |
| Containers start auto | Yes (on Hostinger one-click) | Yes |
What the Hermes Setup Actually Looks Like

On Hostinger, clicking Manage on the VPS row opens Docker Manager, where both Hermes and Traefik are already running.
To reach the actual agent setup, I clicked the port link in the container details, which opened a terminal-based setup wizard in the browser.

The wizard covers:
- Provider selection from a list of 30+ LLM options
- OAuth authentication if using Claude Max or a subscription provider
- Manual URL copy from the terminal, browser authorization, and code paste back into the wizard
- A one-time authentication token that appears exactly once in yellow text
- Model selection (claude-sonnet-4-6 is the default, sensible for most workloads)
- Backend selection (local, Docker, SSH, Modal, and others)
That auth token is the sharpest friction point. Miss it, and you run the full OAuth flow again. The wizard tells you to save it before closing the terminal.
After setup completes, run hermes doctor before your first real task. It surfaces configuration gaps, missing dependencies, and tool connectivity problems in one pass rather than letting you discover them mid-session.
What the OpenClaw Setup Actually Looks Like

OpenClaw Managed on Hostinger is a different experience. The terminal never appears. After checkout, the configuration screen asks for a gateway token (auto-generated) and optional API key fields. Nexos AI Credits, if purchased at checkout, are already wired in. Click Deploy.
Three to four minutes later, the status turns green and shows Running. The OpenClaw web interface is live. Paste your gateway token, click Connect, go to Overview, and confirm STATUS shows OK. That is the entire provisioning path.
Channel connection is conversational. In the Chat tab, type “I want to connect to Telegram,” and the agent returns a numbered sequence.
You follow it, paste the bot token it asks for, and the agent handles the rest. No manual config files. No environment variables. No digging through documentation.

OpenClaw Managed gets you from checkout to a responding agent faster, and without a terminal. Hermes is faster for developers who know the OAuth flow and want the deeper configuration options it exposes during setup. For a non-technical user, OpenClaw Managed is the only realistic path. For a developer, the 10-minute difference is not the deciding factor.
3. Channel & Platform Coverage
The channel gap between the two agents matters for specific use cases.
| Platform | Hermes Agent | OpenClaw |
| Telegram | ✓ | ✓ |
| Discord | ✓ | ✓ |
| Slack | ✓ | ✓ |
| ✓ | ✓ | |
| Signal | ✓ | ✓ |
| iMessage | ✓ via BlueBubbles | ✓ Mac only |
| Email (SMTP/IMAP) | ✓ | ✓ Agentic inbox on Managed plan |
| Microsoft Teams | ✓ | ✘ |
| Matrix / Mattermost | ✓ | ✘ |
| WeChat / WeCom / QQ Bot | ✓ | ✘ |
| DingTalk / Feishu / Lark | ✓ | ✘ |
| SMS | ✓ via gateway | ✘ |
| Home Assistant | ✓ | ✘ |
| Webhooks | ✓ | ✘ |
| Local CLI | ✓ Full interactive terminal | ✓ WebChat interface |
| OpenAI-compatible API server | ✓ localhost:8642/v1 | ✘ |
| Total platforms | 16+ | 7 core + WebChat |
For most personal assistant use cases, OpenClaw’s channel coverage is sufficient. Telegram, Discord, WhatsApp, Slack, Signal, and iMessage cover the messaging apps most people actually use.
Where Hermes pulls ahead is in three specific situations:
- Enterprise deployments that need Microsoft Teams alongside consumer messaging
- Asian market platforms (WeChat, WeCom, DingTalk, Feishu), where OpenClaw has no native support
- Developer workflows where the OpenAI-compatible local API endpoint lets Open WebUI, IDEs, and custom clients connect to the same agent as the messaging platforms
One Hermes advantage that is easy to overlook is cross-platform conversation continuity. Start a conversation on Telegram, pick it up on Discord, or in the terminal, and the agent carries the same memory and session state. Voice memo transcription also works across most Hermes platforms.
4. Security & Control
Both agents have access to your machine. Both need a clear answer to what happens when something goes wrong. They approach this differently.
How Hermes Handles Security

Hermes Agent’s primary security layer is Tirith, a built-in command scanner that runs before the agent executes anything. Its default setting is fail-closed. If the scanner encounters an error or crashes, it blocks the command rather than allowing it through unchecked. This is the more conservative posture, and it is the default without any configuration from you.
Hermes also ships with seven execution backends:
- Local: commands run directly on your machine
- Docker: isolated container, adds a security boundary around execution
- SSH: run execution on a remote machine instead of the host
- Modal: serverless cloud sandbox
- Daytona: persistent cloud development environment
- Vercel Sandbox: cloud microVM with filesystem persistence
- Singularity/Apptainer: HPC-friendly container runtime
For a homelab or personal VPS deployment, local backend is appropriate. For deployments handling untrusted inputs or multi-user environments, Docker isolation adds a second layer of containment around command execution without changing anything about how you interact with the agent.
All data lives in ~/.hermes/. No telemetry, no data collection, no cloud dependency. You can audit every line of code.
How OpenClaw Handles Security

OpenClaw’s security model is session-based. The main session, your direct operator connection, gets full capabilities. DM sessions and group channel sessions are sandboxed by default. Tools that access the network or file system are restricted unless you explicitly open them.
The key security configuration points:
- OPENCLAW_GATEWAY_TOKEN: Required for any non-local connection. Keep this out of version control.
- gateway.auth.mode: Never set to “none” on any public-facing connection.
- Device pairing: Enforced for remote access. Auto-approval applies only to local loopback connections.
- Credentials: Live in ~/.openclaw/credentials/ with 0600 permissions.
- DM and group sessions: Docker sandboxing is available and recommended for untrusted channels.
One concern worth naming directly is that published reports indicate more than 20,000 OpenClaw instances are publicly accessible on the internet with weak or missing authentication.
That is a configuration problem, not an architectural flaw. But it tells you that the defaults do not prevent exposure on their own. If you are running OpenClaw on a VPS, keep the Gateway bound to 127.0.0.1 and use Tailscale or a VPN for remote access.
| Hermes Agent | OpenClaw | |
| Primary security layer | Tirith command scanner (runs before execution) | Session trust tiers (governs what channels can attempt) |
| Default posture | Fail-closed: scanner error = blocked command | Main session: full access. DM/group: sandboxed |
| Execution isolation | 7 backends, including Docker and SSH | Docker, SSH, OpenShell |
| Telemetry | None | None |
| Data location | ~/.hermes/ (local) | ~/.openclaw/ (local) |
| Public exposure risk | Lower (terminal-first, no web gateway by default) | Higher (gateway exposes WebSocket; >20K publicly accessible instances reported) |
The practical distinction: Hermes catches individual dangerous commands before they run. OpenClaw isolates which channels can reach dangerous capabilities in the first place. Neither approach is objectively safer; they address different threat surfaces. Hermes is the stronger choice if you are running untrusted inputs or multi-user workflows. OpenClaw’s session model is well-designed for managing a personal assistant across channels with different trust levels.
5. Long-Term Agent Growth
Both agents can get more capable over time. The mechanism is different, and that difference determines whether you are in control of what the agent learns or whether it learns on its own.
How Hermes Grows

Hermes is designed around compounding. After completing a complex task, tell it to save the approach as a named skill; it then appears in the relevant category, is indexed for future retrieval, and is used automatically the next time the same pattern comes up.
After 5 or more tool calls following the same pattern without you prompting it, Hermes auto-creates a skill via its skill_manage tool.
You can also create skills manually with a skill.yaml file:
- Define name, description, tags, and metadata
- Specify capabilities the skill needs (terminal, code_execution, etc.)
- Add strict output schemas for deterministic behavior
- Skills live in ~/.hermes/skills/ and are immediately active
The bundled skill atlas is extensive enough to cover most MLOps, research, and developer workflows without writing anything custom:
| Category | What’s bundled |
| MLOps | Training, inference, evaluation, vector databases, cloud GPU, models (13 in training alone) |
| GitHub | PR handling, issue flows, code review, repository operations (6 skills) |
| Research | Literature review, market analysis, domain research (7 skills) |
| Software Development | Planning, review, debugging, engineering execution (7 skills) |
| DevOps | Event-driven automation and service hooks |
| Autonomous Agents | Claude Code, Codex, Hermes spawning, OpenCode (4 skills) |
| Media | YouTube research, social curation, content workflows (4 skills) |
| Productivity | Documents, planning, OCR, office tasks (6 skills) |
| Smart Home / Apple / Leisure | Home automation, iMessage, Reminders, Notes, Find My |
How OpenClaw Grows

OpenClaw’s growth model is conversational. You describe what you need, and the agent can create a skill from that description, or you browse ClawHub, the community skill marketplace, and install it with one command.
The agent can write its own skills, but it tends to do so because you asked rather than because it detected a pattern and acted on it autonomously.
The extension system supports channel plugins, memory plugins, tool plugins, and provider plugins. Everything is discoverable from the extensions directory. Before installing anything from community publishers, check the VirusTotal security report on the skill’s ClawHub page.

The agent often prompts you to do this before proceeding.
A key architectural difference in how OpenClaw stores memory is sessions as append-only JSON event logs, memory as SQLite with vectors for hybrid search (BM25 plus vectors). This makes OpenClaw’s memory fast at retrieving context across long histories, but the learning is more about recall than autonomous skill creation.
| Hermes Agent | OpenClaw | |
| Skill creation | Auto-creates from experience + manual + skill.yaml | Conversational creation + ClawHub marketplace |
| Auto-improvement | Yes: triggers after 5+ tool calls on same pattern | No: requires a prompt to create a skill |
| Skill marketplace | Skills Hub + agentskills.io | ClawHub |
| Bundled skills | 97 across 28 categories | Fewer bundled; more community-driven |
| Memory model | Session history, skills, and user profiles in ~/.hermes/ | Hybrid BM25 + vector search in ~/.openclaw/memory/ |
| Can agents share skills? | Yes (agentskills.io open standard) | Yes (ClawHub and RemoteOpenClaw marketplace) |
Some users in the community run both together: Hermes as the reasoning and skill-building layer, OpenClaw as the channel routing and messaging layer for specific platforms. It is a legitimate architecture for advanced deployments that want the strengths of both.
Which Agent Should You Use?
The honest framing is that these two agents are not competing for the same user. The architecture difference, gateway-first versus agent-first, produces two different tools that happen to overlap in the category of “self-hosted AI assistant.”
Hermes is for teams and developers who need an agent that learns on its own, reaches enterprise platforms, and gives them full control over how commands execute. OpenClaw is for anyone who wants a personal assistant running across the apps they already use, set up in under 30 minutes, with one bill at the end of the month.
Use Hermes Agent when:
- You want an agent that improves its own capability over time without being prompted to do so
- Your work involves MLOps, GitHub workflows, AI model training, or research pipelines where the bundled skill atlas pays for itself immediately
- You need to reach your agent from Microsoft Teams, WeChat, DingTalk, or an OpenAI-compatible local API endpoint alongside consumer messaging apps
- You want seven execution backend options, including Docker isolation, SSH remote execution, Modal, and Singularity for HPC environments
- You prefer a command-level security scanner that blocks execution on any failure, rather than session-level trust tiers
- You are comfortable with a terminal session and a manual OAuth step during setup
- You have an existing Claude Max or OpenAI subscription and do not want to pay for AI twice
Use OpenClaw when:
- You want a working AI assistant in 25 minutes with no terminal at all, using the Managed plan on Hostinger
- Your primary use case is personal productivity across WhatsApp, Telegram, and email, with no need for enterprise platform coverage
- You want one bill covering both VPS costs and AI credits, using Nexos AI Credits on the Managed plan
- You prefer to stay in the loop on what your agent learns and installs, rather than having it create skills autonomously on detected patterns
- Multi-agent session routing across different channels and personas matters more to you than automated skill creation
- You are setting this up for a non-technical user who should never encounter a command prompt
- The canvas and A2UI capabilities (agent-generated interactive HTML interfaces) fit your workflow
