Hermes Agent vs OpenClaw

oth are AI agents you run outside a normal chat app, usually from a terminal, so they can use tools, remember context, and keep working across sessions. Hermes is built by Nous Research and is designed to be persistent, tool-using, and “self-improving,” while OpenClaw is another personal AI assistant with its own gateway/onboarding setup.

The big complaint about OpenClaw

The person you’re quoting, Imran, says OpenClaw has three headaches: it doesn’t remember enough by default, its gateway needs too much babysitting, and it doesn’t make token spending obvious. That framing comes from the podcast/episode summary, so treat it as his experience and opinion, not a universal law of physics. What Hermes does officially document is this: it stores session history in a local SQLite database, supports persistent memory across sessions, and keeps token counts and billing metadata in its session store. That is why people talk about Hermes as fixing “memory + stability + cost visibility.”

What “built-in memory” really means

In normal human language, it means your agent stops behaving like it got hit on the head with a frying pan between conversations. Hermes keeps session data in ~/.hermes/state.db with full-text search, keeps curated memory files like MEMORY.md and USER.md, and can also plug into Honcho for a deeper long-term user model, such as your preferences, projects, and patterns across sessions. So when your summary says Hermes “writes to SQLite,” the practical meaning is: the agent stores conversation/session state locally and can retrieve it later instead of starting from psychic infancy every time.

What “gateway stability” means

The gateway is the always-on bridge that lets the agent talk through places like Telegram, Slack, Discord, WhatsApp, SMS, and other channels. Hermes documents a long-running gateway system with many platform adapters, while OpenClaw also has a gateway daemon you install and keep running. Imran’s point is that Hermes has been more stable for him personally. So “gateway stability” means fewer restarts, fewer dropped connections, and less ritual sacrifice to keep the bot alive.

What “token visibility” means

Every time the agent talks to a model, it burns tokens, and tokens usually mean money. Hermes tracks token counts and billing in its session database, and OpenRouter emphasizes posted per-model pricing, pay-as-you-go credits, and activity logs. So “token visibility” means you can actually see what model you used, how many tokens you spent, and what that translated to in cost, instead of discovering later that your agent has been eating dollar bills like a paper shredder with ambition.

“40+ tools and skills out of the box”

That means Hermes arrives preloaded with a lot of capabilities instead of making you go on a scavenger hunt. Official docs say Hermes has 47 registered tools across 19 toolsets, and its bundled skills catalog includes Apple/macOS-specific skills for Notes, Reminders, Find My, and iMessage/SMS. So the claim is: less setup friction, faster time to useful work.

“Single-command install” and hermes model

That part is literal. Hermes documents a one-line installer for macOS, Linux, WSL2, and even Termux on Android. After install, hermes model is the command for choosing your provider/model setup. If you use OpenRouter, Hermes can route through many model options, and OpenRouter exposes transparent pricing plus free-model options. The specific “90% cheaper, from $130 to $10 in five days” number is from Imran’s anecdote, not a guaranteed benchmark for everyone.

Why Android via Termux matters

This is the sneaky-cool part. Hermes officially supports running on Android through Termux, and Termux:API can expose phone functions like SMS, GPS, text-to-speech, vibration, clipboard, and contacts to command-line scripts. So the idea is: an old Android phone becomes a cheap always-on agent box with a battery, radios, and a SIM card. That makes things like SMS handling, lightweight automation, and phone-native actions possible without buying a dedicated Mac Mini. Hermes does note that Android support has limits: some extras like voice and full browser bootstrap are not yet part of the tested path, and background persistence is best-effort.

“One agent is enough, maybe two”

That means: do not build a tiny robot bureaucracy on day one. Hermes supports multiple isolated profiles, each with its own config, memory, sessions, skills, cron jobs, and database, so keeping one agent for personal life and one for work is a sensible split. Hermes also supports both scheduled automations and subagents, which is why your notes mention the cron-vs-subagent question. Cron is “do this every morning.” A subagent is “spawn a helper worker for a specific task.”

Why Obsidian and G-Stack come up

Obsidian is a Markdown-based notes app, so pairing it with Hermes gives you a readable file-based dashboard the agent can organize. G-Stack is Garry Tan’s open-source command/skill pack that turns an AI setup into a little virtual startup team with roles like CEO, designer, engineering manager, doc engineer, and QA. So the suggestion is: use Hermes as the engine, Obsidian as the notebook, and G-Stack as a product-building playbook if you’re building a company or app.

The last line is the real philosophy

“The real skill is defaulting to your agent” means: don’t treat the agent like a novelty toaster. Use it as your first stop for everyday work. Then ask it meta-questions at night like “What am I procrastinating on?” or “What should I automate?” The bet is that the biggest gains do not come from tweaking configs all day, but from making the agent part of your daily workflow and letting it reveal repeatable chores you can turn into tools or automations. That advice comes straight from the episode summary, and it’s more about habit design than software.

My honest bottom line: this is saying Hermes is attractive because it remembers, can run anywhere, comes preloaded, and makes model costs easier to control, while OpenClaw is being framed as more brittle and more annoying to maintain. The cost-savings numbers and stability claims are best read as one user’s field report, while the install flow, built-in tools, bundled skills, session storage, profiles, and Android support are all documented features.

Basic info:

1) Beginner’s glossary

Hermes Agent
A terminal-first AI agent from Nous Research. It is meant to be more than a chat window: it can use tools, keep session history, run through a messaging gateway, and live on your laptop, a server, or even Android via Termux.

OpenClaw
Another personal AI assistant/agent project. Its docs emphasize a quick install plus an onboarding flow that sets up the gateway, auth, workspace, channels, and skills.

Agent
Here, “agent” means an AI system that can do multi-step work with tools, memory, terminal access, and sometimes background-style workflows, rather than only answering one prompt at a time. Hermes describes itself as an autonomous agent, not just a chatbot wrapper.

Built-in memory
Hermes keeps persistent notes like MEMORY.md and USER.md, and also stores all CLI and messaging sessions in a local SQLite database at ~/.hermes/state.db. That lets it recall ongoing preferences and search past conversations later.

SQLite
A lightweight local database file. In Hermes, it stores session metadata, message history, token counts, and billing-related metadata. Think of it as the agent’s filing cabinet, not a cloud brain in a jar.

Session search
Hermes can search old conversations using SQLite full-text search. That is different from short memory files: short memory is “always keep this in mind,” while session search is “go look up what we talked about last week.”

Gateway
The long-running bridge that lets Hermes work through messaging platforms like Telegram, Discord, Slack, WhatsApp, Signal, Email, and Home Assistant. It also runs cron jobs. When people say “gateway stability,” they mean whether that always-on bridge stays alive without constant restarts.

Token visibility
Visibility into how many tokens you used and what they cost. Hermes stores token counts and billing info in session storage, and also exposes usage analytics through commands like hermes insights, /usage, and /insights.

Tools / toolsets
These are the actions Hermes can perform, like web search, browser automation, terminal commands, file editing, memory, messaging delivery, and more. Hermes docs currently show a large built-in registry; one architecture page says 47 tools across 19 toolsets, while the tools reference currently documents 53 tools, so the count appears to be evolving.

Skills
Reusable knowledge/workflow packs that Hermes can load on demand. They are token-efficient and live in ~/.hermes/skills/. Installed skills also become slash commands.

Bundled Apple skills
On macOS, Hermes ships bundled Apple-oriented skills such as Apple Notes, Apple Reminders, Find My, and iMessage/SMS. That is why Mac users get extra toybox perks out of the gate.

Profiles
Separate Hermes identities on the same machine. Each profile gets its own config, API keys, memory, sessions, skills, cron jobs, and state database. This is how you keep “work bot” and “personal bot” from sharing soup.

OpenRouter
A model-routing service that gives access to many models/providers through one API. OpenRouter says it offers transparent pricing, activity logs, budgets/spend controls, no minimum spend on pay-as-you-go, and support for auto-routing/fallback.

Termux / Termux:API
Termux is an Android terminal environment. Termux:API is the companion layer that exposes Android device features to command-line tools, such as SMS or GPS-related functions. Hermes has a documented Android/Termux install path.

Honcho
An optional Hermes memory provider for deeper cross-session user modeling. Hermes describes it as adding reasoning-driven user profiling and session-scoped context beyond the built-in memory files.

Obsidian
A Markdown-based notes and knowledge app. Obsidian describes itself as a tool for organizing ideas, journaling, project management, and connected notes, which makes it a natural front-end for an agent that can organize Markdown files.

G-Stack
Garry Tan’s open-source skill/tool setup. Its GitHub describes it as “23 opinionated tools” serving roles like CEO, Designer, Engineering Manager, Release Manager, Doc Engineer, and QA. It is not an official YC product, but a public repo with a very startup-pilot vibe.

2) “Should I care about Hermes?” decision guide

You should care about Hermes if you want an AI that behaves more like an operator than a chat tab. The strongest reasons are persistent sessions, built-in memory, tool use, messaging-gateway support, multiple isolated profiles, and the option to run locally, in Docker, over SSH, or on other backends. If that sentence made your brain light up like a pinball machine, Hermes is probably your kind of weird.

Hermes is especially attractive if your current pain is repetition. Its built-in memory plus searchable session history means you do not have to keep reteaching the same preferences, project context, or long-running threads. That is one of the core reasons people pitch it as a step up from lighter-weight agents.

It is also a good fit if you want cost awareness. Hermes stores token and billing metadata in session storage and exposes analytics commands, while OpenRouter offers published pricing, activity logs, budgets, and spend controls. So if you hate black-box billing, this stack is notably less foggy than the usual wizard cave.

You should especially pay attention if you are a Mac user who wants native-ish automation. The bundled Apple skill catalog includes Apple Notes, Reminders, Find My, and iMessage/SMS on macOS, which gives Hermes more “useful but slightly nosy butler” potential on a Mac than on generic Linux.

Hermes may be overkill if what you really want is just “a better chatbot.” The docs assume some comfort with terminal commands, provider setup, configuration files, models, tools, and sometimes gateway setup. That is not impossible, but it is definitely more workshop than toaster.

It may also be the wrong first move if you do not want an agent touching your machine. Hermes’ default terminal backend is local, and the docs explicitly warn that this gives the agent the same filesystem access as your user account unless you disable tools or switch to Docker for isolation. That is not a flaw, exactly, but it is a serious grown-up-pants setting.

My practical take:
Use Hermes if you want a daily-driver agent for real work, notes, automation, or multi-step tasks.
Skip Hermes for now if you want zero setup, maximum simplicity, or you do not trust an agent with tool access.
Start with one profile unless you have a clear reason to split work/personal. Hermes supports many profiles, but the docs themselves make it easy to keep things simple first.

3) Mac tutorial for beginners

This is the “get it working without summoning command-line goblins” version.

Before you start

Hermes’ official installer for macOS is:

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

Hermes says the only prerequisite is Git. The installer handles the rest, including Python, Node.js, ripgrep, ffmpeg, the repo clone, virtualenv setup, and the global hermes command.

First, open Terminal on your Mac and check Git:

git --version

If macOS complains that developer tools are missing, install Apple’s Command Line Tools. Apple’s developer documentation says command-line tools can be installed from Terminal, and Apple’s developer forum gives the standard command as:

xcode-select --install

Then re-run git --version.

Step 1: Install Hermes

Run:

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

After the installer finishes, reload your shell:

source ~/.zshrc

If you use bash instead of zsh:

source ~/.bashrc

Then launch Hermes:

hermes

That matches the official install and post-install flow.

Step 2: Choose your model provider

The next important step is provider setup. Hermes recommends:

hermes model

That command is the full provider/model wizard. It can add providers, prompt for API keys, run OAuth-backed setups, and save your default. Hermes’ docs recommend OpenRouter or Nous Portal as low-friction defaults, and specifically call out OpenRouter when you want multi-provider routing.

For a first pass, I’d suggest:

• choose OpenRouter
• paste your OpenRouter API key when asked
• pick a model with at least 64K context, because Hermes requires that minimum context window for multi-step workflows

If you do not have OpenRouter yet, it offers free models, pay-as-you-go, and no minimum spend on pay-as-you-go. It also exposes activity logs, budgets, and spend controls.

Step 3: Start your first chat

Now run:

hermes --tui

or, if you want the simpler classic interface:

hermes

Hermes’ quickstart says both interfaces share the same sessions, slash commands, and config. The TUI is the recommended modern interface.

Try one of these first prompts:

Check my current directory and tell me what looks like the main project file.

What tools do you have available right now?

Summarize this machine setup and tell me what is configured.

A successful first run should show your chosen model/provider, return a normal answer, and keep the conversation going across multiple turns.

Step 4: Make sure sessions actually persist

Close Hermes, then test resume:

hermes --continue

or:

hermes -c

If it returns to your previous session, the memory plumbing is alive and the little ship is floating. Hermes stores CLI sessions in ~/.hermes/state.db.

Step 5: Learn the few commands that matter first

These are the ones I would memorize:

hermes model
hermes tools
hermes setup
hermes doctor
hermes sessions list
hermes insights

Inside a session, the most useful slash commands are:

/help
/tools
/model
/usage
/insights

hermes model is the full provider wizard from the terminal. /model inside a session only switches among already-configured providers/models.

Step 6: Understand where Hermes stores things

Hermes uses ~/.hermes/ as home base. Important pieces include:

• config.yaml for settings
• .env for secrets/API keys
• SOUL.md for primary identity
• memories/ for memory files
• skills/ for local skills
• cron/ for scheduled jobs
• state.db for sessions, messages, token counts, and billing metadata

That split matters because secrets go in .env, while regular settings go in config.yaml. Hermes handles that routing automatically when you use hermes config set.

Step 7: Mac-only goodies

On macOS, Hermes includes bundled Apple skills for:

• Apple Notes
• Apple Reminders
• Find My
• iMessage / SMS

That is one of the nicest reasons to run Hermes on a Mac specifically. You are not just running a general agent, you are giving it access to some native-ish hooks your laptop already speaks.

Step 8: Keep it safe

By default, Hermes’ local backend runs commands directly on your machine with no isolation. The docs warn that this gives the agent the same filesystem access as your user account. For a safer setup, switch to Docker:

hermes config set terminal.backend docker

Hermes documents Docker as the sandboxed backend and notes that on macOS it can find Docker in common install locations, including Docker Desktop paths.

My advice for a Mac beginner:

• start with local only if you are just testing
• switch to Docker once you begin trusting it with real work
• use hermes tools to disable anything you do not want available

Step 9: Optional, but worth it

If you want a browser UI for config and sessions:

pip install hermes-agent[web]
hermes dashboard

That opens a local dashboard at http://127.0.0.1:9119. Hermes says it runs entirely on your machine.

If you want Hermes available in chat apps later:

hermes gateway setup

And on macOS, the gateway can be installed as a launchd user service:

hermes gateway install
hermes gateway start

Hermes documents that hermes gateway install maps to launchd on macOS.

Step 10: The best first real setup

If I were setting this up for a Mac user from scratch, I’d do it in this order:

1. Install Hermes
2. Run hermes model and choose OpenRouter
3. Start hermes --tui
4. Confirm hermes --continue works
5. Try /usage and hermes insights so cost is visible
6. Explore Apple Notes / Reminders skill usage
7. Move terminal backend to Docker when you want safer automation
8. Only then bother with gateway, cron, Honcho, Obsidian, or G-Stack

A very short “what all this means” summary

The original notes are really saying this:

Hermes is appealing because it tries to be a persistent, tool-using, cost-visible AI worker instead of a forgetful chat box.
For Mac users, the bonus layer is Apple Notes, Reminders, Find My, and iMessage/SMS support.
For careful users, the caution flag is that powerful agents need setup and should be sandboxed once they start touching real files.