Hermes 101 — Agent ที่เติบโตไปกับเราHermes 101 — The Agent That Grows With You

Readers of this blog already know their way around agent harnesses — my seven-part OpenClaw for Organizations series walked from first install to production, and I still run my own OpenClaw deployment every day. Yet for the past half year, the name students and colleagues ask me about most is not OpenClaw. It is Hermes Agent from Nous Research — an open-source project that has grown too fast for anyone working in this field to politely ignore.

Its pitch is seductive: install in under a minute, wire Telegram, Slack and your terminal into one continuous conversation, and let the agent "grow with you" over time. Seductive pitches are exactly the ones an academic should test hardest.

This new series, "Hermes Agent in Practice 2026", is that test — seven posts, same skeleton as the OpenClaw series so the two can be compared honestly. This first post lays the foundation: what Hermes is (and is not), how the architecture fits together, how to install it, where the money actually goes, and how much effort a move from OpenClaw really costs.

1. Why Another Agent? Hermes After OpenClaw

Hermes Agent is an open-source agent harness — MIT-licensed, written in Python — from Nous Research, publicly launched on 25 February 2026 at github.com/NousResearch/hermes-agent under a repo description that became its slogan: "The agent that grows with you."

The growth numbers are remarkable. Hermes Atlas — a community project unaffiliated with Nous — reports the repo reaching 57,200 stars within its first six weeks, faster than OpenClaw at the same stage. By July 2026, TechCrunch put it at roughly 214,000 stars; on the day I write this (1 September 2026), GitHub shows nearly 240,000 stars and close to 49,000 forks.

One clear tailwind came in April 2026, when Anthropic blocked personal subscription (Pro/Max) access through third-party harnesses — a change that hit every harness equally. Hermes Atlas records a visible rise in migration traffic in early April following that announcement, and through the following weeks Hermes's usage on OpenRouter climbed until it overtook OpenClaw for the top spot in daily tokens around mid-May 2026.

Behind the project stands Nous Research, founded in 2023 by Jeffrey Quesnelle, Karan Malhotra, Ryan Teknium and Shivani Mitra, with roughly $70M raised to date. Per TechCrunch's July 2026 reporting, the company is in talks — not closed — for at least $75M more at a $1.5B valuation.

So what does "grows with you" actually mean? Two mechanisms carry the claim: bounded memory — agent-curated memory files kept under a hard size budget, backed by full-text search across every past transcript — and a learning loop that lets the agent create and refine skills from its own experience. Each deserves a full post, and each gets one (#3 Memory and #6 Skills). For this 101, the pin to place is simply that this is the design bet separating Hermes from the previous generation of harnesses — and the bet this series will scrutinise hardest.

The ecosystem in numbers

The metric I weight more heavily than stars is the density of the ecosystem around a project. The Hermes Atlas April 2026 snapshot counted over 80 community projects, 17 skill libraries, and roughly 90,750 stars across the wider ecosystem, while the main repo's contributor count grew from 242 in March to over 274 within a single month.

Nous itself matches the community's pace — the company states that co-founder Teknium personally landed 179 PRs in the v0.8 development cycle alone, and Hermes Agent now sits among the company's headline products alongside Hermes 4, Nous Portal, Nous Chat and Simulators.

💡 My view: GitHub stars are not evidence of quality, but they are evidence of momentum — and in open source, where the community fixes the bugs and writes the integrations, momentum is a real variable that anyone choosing tooling for an organisation has to price in.

2. Hermes Agent vs Hermes Models — Don't Confuse the Two

Before going further, we need to clear up the single most common confusion, because Nous Research uses the name "Hermes" for two entirely different product lines.

The first is Hermes 4 — a family of open-weight, hybrid-reasoning models released around August 2025 in 14B, 70B and 405B parameter sizes, built on Qwen3 and Llama 3.1 bases. The second is Hermes Agent — the Python harness this series is about, which is not tied to Hermes models at all: it runs against any model, commercial or open-weight.

3. Architecture at a Glance: CLI, Gateway Daemon, One Session Plane

Hermes runs in dual mode. On one side sits an interactive CLI/TUI for desk work — multiline editing, slash-command autocomplete, and the ability to interrupt the agent mid-task and redirect it. On the other side sits a single gateway daemon that receives messages from every chat platform. The project README states it plainly: "Telegram, Discord, Slack, WhatsApp, Signal, and CLI — all from a single gateway process" (additional channels such as Email live a layer down in the docs), plus a cron subsystem for scheduled jobs.

The design decision I consider most important is the single session plane: whether you type in the CLI, message the agent on Telegram, or let cron wake a job at 3 a.m., everything attaches to the same session system. The agent carries context across channels — unlike setups where the chat bot and the terminal tool are effectively two strangers with separate memories.

Under the hood, the best architectural deep-dive so far is a third-party analysis by Arize (Nous has published no first-party equivalent yet). Its key findings:

• Sessions are infrastructure: stored in SQLite with full-text search (FTS5) and WAL journaling; each turn is source-tagged, with parent-child lineage preserved when conversations are compressed
• Long-context handling: older turns are summarised by an auxiliary model, with the head and tail of the conversation protected by a token budget so they are never summarised away
• Tool registration is separated from tool exposure: every tool registers in a central registry at import time, but a distinct toolset layer decides what the model actually sees in a given context — a distinction that will matter greatly when we reach post #4 on security
• The system prompt assembles in three tiers (stable / context / volatile) and automatically reads context files such as AGENTS.md, CLAUDE.md and .cursorrules from the working directory

For execution, the README lists seven backends, verbatim: "local, Docker, SSH, Singularity, Modal, Daytona, and Vercel Sandbox."

• local — runs directly on your machine; the simplest start
• Docker — isolates the agent's work in a container
• SSH — drives a remote machine over SSH
• Singularity — the container flavour familiar to HPC and university clusters
• Modal / Daytona — the serverless pair: environments hibernate when idle, which the README positions as costing nearly nothing between sessions
• Vercel Sandbox — sandboxed execution on Vercel's infrastructure

For a 101, knowing the options exist is enough — choosing the right backend for real workloads and multi-user setups is a full topic for post #7 on production.

💡 If you read the OpenClaw series, this picture will feel familiar: the central gateway joining many channels is the pattern OpenClaw made mainstream. What Hermes adds is promoting sessions to first-class infrastructure (SQLite + FTS5) and deliberately separating the tool-exposure layer from day one.

4. Install in 60 Seconds — and What Lands on Disk

The prerequisites are surprisingly thin: you need Git, and on Linux additionally curl and xz-utils. Everything else the installer handles itself — it fetches uv, Python 3.11, Node.js v26, ripgrep and ffmpeg per-user, with no sudo at all. The full details are in the official installation docs.

# Linux / macOS / WSL2 / Termux — one line
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

# reload PATH, then run it
source ~/.bashrc
hermes

# Windows — PowerShell
iex (irm https://hermes-agent.nousresearch.com/install.ps1)

For anyone allergic to terminals, native desktop installers exist for macOS 12+ and Windows 10/11. For server people: the README keeps hardware positioning deliberately broad — verbatim, "Run it on a $5 VPS, a GPU cluster, or serverless infrastructure that costs nearly nothing when idle" — and no official minimum spec is published. So I will say "a $5-VPS-class box is enough to start" and resist inventing RAM/CPU numbers the vendor never printed.

What lands on disk

The installer keeps everything in user space and touches nothing system-wide:

# after install (Linux / macOS — per-user)
~/.hermes/                  # all agent config and state
~/.hermes/hermes-agent/     # the harness code itself
~/.local/bin/hermes         # the binary you invoke

# Windows (native install)
%LOCALAPPDATA%\hermes\      # everything lives under this folder

# root/system-wide install (e.g. on a server)
/usr/local/lib/hermes-agent/   # code
/usr/local/bin/hermes          # binary
/root/.hermes/                 # state (or set your own via $HERMES_HOME)

Having the entire state under ~/.hermes/ makes backup trivially easy — copy one folder and you have config, sessions and memory. We will lean on that property hard in post #7 on production operations.

One detail I particularly enjoy: the installer's supported-platform list includes Termux — meaning the same one-liner installs Hermes on an Android phone. That fits the project's run-anywhere philosophy quite deliberately.

5. First Run: setup, model, tools, portal, gateway

After installation, first-time configuration is a short command sequence the README lays out explicitly, starting with the wizard:

# 1) run the first-time setup wizard
hermes setup

# 2) choose your provider and model
hermes model

# 3) list tools, and enable/disable them individually
hermes tools

If you use Nous Portal (the Nous cloud service — details in the next section), there is an even faster path: a single OAuth grants both a model and every Tool Gateway tool at once. This is the route that keeps "install in 60 seconds" from being pure marketing:

# one OAuth — a model plus the full Tool Gateway toolset
hermes setup --portal

# check account status and remaining credits
hermes portal info

The final step, for anyone who wants the agent living inside a messaging app, is the gateway:

# configure chat channels (Telegram, Discord, Slack, WhatsApp, Signal)
hermes gateway setup

# start the daemon — one process serves every channel
hermes gateway start

During a conversation, you can switch models live with a slash command — no config edits, no restart:

# switch models mid-conversation — provider:model form
/model <provider:model>

My recommended order for the first hour:

1. Install with the one-liner, then run hermes setup and answer the wizard to the end
2. Pick a model with hermes model (or hermes setup --portal if you have decided on Portal)
3. Work with the agent CLI-only for a day — try document summaries, research questions, small coding tasks
4. Review hermes tools and disable what you do not yet need
5. Configure the gateway last, once you understand how the agent behaves

The reason for step 5: plugging an agent you do not yet understand into Telegram in hour one is a recipe for accidents — a lesson the OpenClaw era taught the hard way, and one post #4 on security will unpack with evidence.

Cheat sheet — every command in this post

hermes setup             # first-time setup wizard
hermes model             # choose provider / model
hermes tools             # list and manage tools
hermes setup --portal    # one OAuth via Nous Portal
hermes portal info       # account status and credits
hermes gateway setup     # configure chat channels
hermes gateway start     # start the gateway daemon
hermes claw migrate      # migrate from OpenClaw
/model provider:model    # switch models mid-conversation (in-session)

6. Models and Money: MIT-Free Software, 300+ Models, Portal Tiers

The money story splits into three layers, and keeping them separate matters because much of the internet writes them into one confused blur.

Layer one — the software: genuinely free. Hermes Agent is MIT-licensed and runs on your own machine at zero software cost, and the README leans hard on model independence — "no code changes, no lock-in."

Layer two — the models: pay whoever you choose. The strength here is breadth: the README advertises "300+ models" via Nous Portal, alongside OpenRouter, OpenAI, Google AI Studio, or any custom endpoint — roughly twenty-plus providers in total, all switchable live through /model as shown above.

Layer three — Nous Portal: the optional subscription. Pricing as listed at portal.nousresearch.com on the day of writing:

The subscription bundles hosted tools: web search and scraping (Firecrawl), image generation (FAL, Krea), cloud browser automation (Browser Use) and speech/TTS (OpenAI). TechCrunch independently corroborates the $20–$200 monthly range. There is also Hermes Cloud — an always-on instance Nous provisions for you, billed hourly against Portal credits and scaling to zero when idle. Its hourly rate is not published, so I will not print one.

For organisations: Hermes Cloud entered public preview around July 2026 with team-level features — Nous's official announcement describes it as letting you "spin up agents for everyone at your org with granular access controls and unified billing, all from Nous Portal", and the Cloud page sets the entry condition at a minimum of $10 in credits or an active subscription to deploy. We will weigh those org-level access controls seriously in posts #4 (Security) and #7 (Production).

7. Coming from OpenClaw: hermes claw migrate

This section is written specifically for readers of my earlier series. Nous knows perfectly well that its most valuable prospective users are people with a working OpenClaw setup, so it shipped the defection tool as a single command:

# migrate from OpenClaw — auto-imports the whole setup
hermes claw migrate

# verify: imported skills are kept separate, here
ls ~/.hermes/skills/openclaw-imports/

What the command handles for you:

• Skills: imported into ~/.hermes/skills/openclaw-imports/, kept apart from skills born on the Hermes side — both ecosystems share the SKILL.md standard (agentskills.io), so the core format is portable
• Memory: all of OpenClaw's daily log files are parsed, merged and deduplicated into Hermes's single bounded MEMORY.md
• Messaging tokens: chat-channel credentials come across too, sparing you a second round of gateway setup

The memory item is the sharpest philosophical difference between the two camps. Readers of my OpenClaw Memory post will remember the MEMORY.md + USER.md pair plus append-forever daily logs — a structure that grows without limit. Hermes bets the opposite way: hard caps on the curated memory files (the Hermes Atlas April snapshot puts them at roughly 2,200 characters for MEMORY.md and 1,375 for USER.md), compensated by FTS5 search across the full transcript history. Which side is right is a question big enough to fill post #3 entirely.

One migration-cost reducer people overlook: Hermes reads other ecosystems' context files directly. An organisation that has already invested in a good CLAUDE.md or AGENTS.md keeps using it from day one, unconverted:

# Hermes reads these from the working directory automatically
AGENTS.md       # the cross-harness convention
CLAUDE.md       # your existing file from the Claude Code / OpenClaw era
.cursorrules    # Cursor's file works too

The interesting part is that migration runs in both directions, and both vendors document their side — OpenClaw maintains an official guide for users coming back from Hermes. That is what a genuinely contested user base looks like, and it is good news for users: switching costs are falling in both directions, and the bargaining power sits with us.

8. The Road Ahead: What This Series Covers

Hermes moves fast enough that any article ages in weeks — as this post goes out, the latest release is v0.21.0 (tag v2026.8.31, published 31 August 2026). To see the cadence, here are the milestones verifiable from the GitHub releases page and from Hermes Atlas's reporting — with the caveat that the early release history is only partly visible (the oldest release still shown on GitHub is v0.2.0, tag v2026.3.12, so nobody can confirm which version launch day ran):

• v0.8.0 (8 Apr 2026) — closed out the heaviest early cycle (the one where Teknium alone merged 179 PRs), including worktree cleanup work
• v0.20.0 (3 Aug 2026) — the big one: streaming voice, an Agent-to-Agent protocol, artifacts, webhooks
• The v0.20.x train (through Aug 2026) — rapid patches: migration to MCP 2.x, skill security scanning, Bot Mode group threads, consent-gated browser profiles
• v0.21.0 (31 Aug 2026) — Bot Mode — a society of named agents with their own faces and group chats — fully bundled into the desktop app (the feature began life earlier as a public beta plugin)

Mid-year was not empty either — external release trackers record the v0.19.0 cycle around July as focused on speed, reporting a roughly 80% cut in first-turn cold-start time (a third-party figure I have not seen Nous confirm itself, so I note it with that condition attached).

The plan for all seven posts — deliberately the same skeleton as the OpenClaw series, so the two can be compared like for like:

• #2 Agent Teams: delegate_task, the durable Kanban board, and Bot Mode — Hermes has several distinct multi-agent layers that must not be conflated
• #3 Memory: the bounded-memory-plus-FTS5 philosophy versus OpenClaw's daily logs — and its limits
• #4 Security: Hermes was designed with the OpenClaw era's accidents in mind, yet has accumulated CVEs of its own — both halves of that story
• #5 Integrations: chat channels, MCP, webhooks and the A2A protocol
• #6 Skills: the learning loop that lets the agent write its own skills — tested live, not taken on faith
• #7 Production: the seven backends, Hermes Cloud, monitoring, and lessons learned

I intend this series as an examination, not a cheer. Where the evidence is third-party or unproven, I will say so plainly — as I have done throughout this post — and where Hermes genuinely delivers, it will get credit on the same standard of evidence.