Hermes Agent – A PM's Field Guide and how to set up | Hermes Agent Certification

In February 2026, a small research lab called Nous Research shipped an open-source project built on a primary premise: what if your AI got smarter the longer you used it? What if it remembered your projects, learned your preferences, wrote down its own procedures, and ran errands for you while you slept?

Four months later, Hermes Agent has crossed 175,000 GitHub stars and attracted nearly a thousand contributors. In May it overtook OpenClaw, the previous open-source darling, to become the most-used open-source agent on OpenRouter’s daily inference rankings, processing over 220 billion tokens in a single day. By most measures it is the fastest-growing open-source agent framework of 2026.

This is a field guide for professionals, especially product managers, who want to understand what Hermes is, how to actually use it, what it costs, where the sharp edges are, and what its design teaches us about where AI products are headed. It’s long because the topic deserves it. Skim the headers and dive where you’re curious.

The easiest way to understand Hermes is by what it refuses to be. It’s not a coding copilot living inside your IDE, and it’s not a chat window you visit. It’s a persistent process that runs continuously on a machine you control: your laptop, a $5/month cloud server, or serverless infrastructure that hibernates when idle.

Once it’s running, three things separate it from everything else you’ve used.

It lives where you already are. Hermes connects to more than twenty messaging platforms from a single gateway, including Telegram, Slack, Discord, WhatsApp, Signal, email, SMS, and Microsoft Teams. You don’t open an app to use it. You text it. Start a conversation from Slack at your desk, continue from Telegram on the train, and it’s the same session, same context, same agent.

It remembers. Hermes keeps a curated, persistent memory of who you are, what you’re working on, and what it has learned, and it can search every past conversation it has ever had with you. More on the mechanics below, because they’re clever.

It improves itself. When Hermes completes a complex multi-step task, it can write the procedure down as a reusable “skill,” a small instruction document it consults the next time something similar comes up. Over weeks it accumulates a private playbook tailored to your work. Nous calls this the learning loop, and it’s the project’s core differentiator.

It’s also model-agnostic. Hermes is the harness, not the brain. You plug in Claude, GPT, Gemini, DeepSeek, Kimi, or any of 300+ models, and switch between them with one command. No lock-in, which is itself a product stance.

Master Claude Code & Hermes Agent hands-on, then learn to evaluate agentic systems like a pro. Go from simply using AI to building full-stack applications & deploying autonomous agents.

3 learnable skills: directing Claude Code like an eng team, operating a Hermes Agent that runs 24/7 on your own infrastructure & gets smarter every week, & evaluating agentic systems so you can prove they work instead of hoping they do.

3 weeks. Your machine. Your real work. By the end, you have running agents.

✨ Week 1 — Hands-on Claude Code: Specs, plans, subagents, skills, MCP. You’ll ship a working tool by Friday.

✨ Week 2 — Hands-on Hermes Agent: Deploy it on your own infra, connect it to Slack/Telegram, put it on a schedule, & customize it to your specific use cases.

✨ Week 3 — Evals for Agentic Systems: Define success, build eval sets, catch failure modes & ship agents you can defend in a roadmap review.

𝙏𝙤𝙤𝙡 𝙡𝙞𝙨𝙩 Claude Code, Hermes Agent & practical eval tooling & patterns you can apply to any agent.

No coding experience required. If you can write a paragraph, you can drive these tools. SIgn-up Here with the discounted rate until end of June 8. Interested in this as a bundle with Marily’s AI Product Bootcamp or a private training? We can send you a custom invoice, reach out to Marily at maven@aiproduct.com. FREE Lightning Lesson on Hermes here.

Here’s the honest on-ramp. You need a terminal, or as of May the new desktop app for Mac and Windows, which wraps the same agent core in a GUI. Same memory, same skills, same sessions across both surfaces.

Step one: install. One command on Linux, macOS, or WSL2:

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

The installer handles Python, dependencies, everything. No sudo required.

Step two: connect a model. The path of least resistance is Nous Portal, the lab’s subscription gateway:

hermes setup --portal

One OAuth login gets you 300+ models plus the bundled Tool Gateway: web search, image generation, text-to-speech, and browser automation, without signing up for Firecrawl, FAL, ElevenLabs, or any of the other five services you’d otherwise need accounts with. You can also bring your own OpenRouter or OpenAI key if you prefer.

Step three: talk to it.

hermes

You’re now in a full conversational CLI with file access, a terminal, and web tools. Ask it to summarize a folder of documents. Ask it what skills it has.

Step four: give it a phone number, so to speak. Run the gateway setup to connect Telegram or Slack. This is the moment Hermes stops being a terminal toy and becomes a personal agent, because now you can message it from anywhere, and it can message you.

Step five: schedule something. Hermes has a built-in cron system you configure in plain English. Tell it: “Every weekday at 8am, search for the top three stories about AI agents, summarize them with links, and send the briefing to my Telegram.” It creates the job itself. Tomorrow morning, your agent texts you first.

That’s the whole loop: install, connect, chat, deploy to messaging, automate. An hour, give or take, and most of it is waiting on OAuth screens.

PMs should slow down for this part. Hermes’s memory architecture is a sequence of unusually disciplined product decisions, and a useful case study in designing for LLMs.

Hermes’s persistent memory is two markdown files. MEMORY.md holds the agent’s own notes about your environment, your conventions, and lessons learned, capped at roughly 2,200 characters. USER.md holds its model of you, meaning preferences, communication style, pet peeves, capped at about 1,375 characters. Together that’s roughly 1,300 tokens, injected into every conversation.

Your instinct might be that this is tiny. That’s the point. Every byte of memory rides along in every prompt, costing money and diluting attention. Unbounded memory is how you get an agent that’s expensive, slow, and weirdly fixated on something you said in March. So Hermes forces a budget. When memory fills up, the agent has to consolidate, merging three stale notes into one dense one, before it can save anything new. The constraint produces curation. Scarcity is the feature.

There’s a lesson here that travels well beyond agents: when your product’s intelligence depends on context, deciding what to forget matters as much as deciding what to remember.

Bounded memory would be crippling if it were the only memory. It isn’t. Every conversation Hermes has ever had is stored in a local SQLite database with full-text search. When the agent needs to recall that thing you discussed three weeks ago about the pricing page, it queries its own history. That’s a 20-millisecond database lookup that costs zero LLM tokens, instead of carrying everything everywhere.

So the architecture is a small, expensive, always-present working memory backed by a vast, cheap, on-demand archive. Power users can bolt on external memory providers for knowledge graphs and semantic search, but the default two-tier design covers most needs. If that division of labor sounds like how you’d design a caching layer, or how human memory works for that matter, it should.

Memory stores the what. Skills store the how. A skill is a markdown document with trigger conditions, a step-by-step procedure, known pitfalls, and a way to verify success. The agent loads it only when relevant. The loading itself is token-efficient through what the docs call progressive disclosure: the agent first sees a cheap index of skill names and one-line descriptions, and pulls full instructions only for the skill it needs.

Here’s where it gets interesting for users: the agent writes its own skills. Finish a gnarly multi-step task, say pulling churn data, cross-referencing support tickets, and formatting a weekly retention summary, then tell Hermes to “save what you just did as a skill called retention-report.” Next week you type /retention-report and the whole procedure runs from the playbook. Skills can even edit themselves when they hit a snag mid-run, and a recent release added an autonomous Curator that grades, consolidates, and prunes the skill library so it doesn’t rot.

One strategic detail: Hermes skills use the SKILL.md format that Anthropic published as an open specification in late 2025, a standard that Microsoft, OpenAI, Google, and dozens of other tools adopted within months. Your skills are portable files, shareable through a community hub, not assets trapped in one vendor’s silo. Nous chose interoperability over a moat, and rode a standard instead of fighting one. That’s a move worth studying.

Put it together and you get the actual product promise. Week one, Hermes is a capable but generic assistant. Week six, it knows your stack, your tone, your recurring reports, and has a dozen private skills for your specific workflows. The switching cost isn’t a contract. It’s an accumulated relationship. That’s the retention mechanic, and it’s a more honest one than a data-export fee.

The software is free. MIT-licensed, no premium tier, no per-seat pricing, every feature in the open-source build. Nous makes money on the plumbing around it: the Portal subscription (Plus at $20/month, Super at $100, Ultra at $200, all bundling model access, monthly credits, and the tool gateway) and managed hosting. Another pattern worth noting: give away the product, monetize the convenience.

Your real costs are two lines. Infrastructure first: Hermes needs one vCPU, 2GB of RAM, and 20GB of disk, which is a $5 to $7 per month VPS, or hardware you already own. Then inference, which varies enormously, and this is where newcomers get hurt. On a budget model, a typical personal-assistant workload runs a few dollars a month. Point the same agent at a frontier model, leave verbose defaults on, run heavy automations, and the bill gets painful. One widely shared community post-mortem described taking the default setup at face value and ending the month with a $400 OpenRouter invoice.

The cost discipline is simple. Use cheap models for routine scheduled jobs and save the expensive ones for work that needs the horsepower. Keep memory and context files lean, since they ride in every prompt. And check your provider dashboard during week one rather than at the end of the month.

A persistent agent with shell access, your credentials, and a messaging inbox is a fundamentally different risk object than a chat tab. It would be malpractice to write this guide without saying so plainly.

An independent audit of Hermes in April 2026 reviewed roughly 364,000 lines of code and found no malware, no backdoors, and no telemetry. Reassuring on intent. It also found four critical and nine high-severity architectural issues. The headline one: on the default local backend, the agent’s terminal tool passes commands straight to the shell with no sandbox and no allowlist. In plain terms, a default install gives the LLM real shell access to your machine. A handful of CVEs have since been disclosed against specific components, and security researchers have flagged the broader threat classes that come with this whole product category: malicious skills from community marketplaces, prompt injection smuggled into content the agent reads, and the trust boundaries around third-party tool servers. None of this is unique to Hermes. Its predecessor OpenClaw had a far rougher run, with nine CVEs disclosed in a four-day window and an audit that found hundreds of malicious skills in its community hub, most tied to a single credential-stealing campaign.

Nous has been hardening fast. There’s now an unoverridable blocklist for catastrophic commands, sensitive environment variables get stripped from anything the agent executes, and memory entries are scanned for injection patterns and invisible-Unicode tricks before they’re accepted. But the practical guidance for a professional is simple and non-negotiable.

Run Hermes in a sandbox, not on the laptop that holds your SSH keys and browser sessions. A Docker backend or a cheap dedicated VPS costs almost nothing and contains almost everything. Treat community skills like browser extensions from an unknown developer, and read them before installing. Don’t hand the agent credentials beyond what its actual jobs require. And keep command approvals on. The convenience of auto-approve is exactly what an attacker is counting on.

If you take one sentence from this section, take this one: the question isn’t whether Hermes is safe, it’s whether your deployment of it is.

Versus OpenClaw. OpenClaw invented this category’s modern form in late 2025, the always-on personal agent you talk to over WhatsApp, and went viral first. Hermes is openly a descendant. Its installer literally detects an OpenClaw directory and offers to migrate your settings, memories, and skills. Hermes won the spring of 2026 on two fronts. It shipped the learning loop, with self-created and self-improving skills plus curated memory, as a first-class feature rather than an add-on. And it benefited enormously from OpenClaw’s security crisis, which sent users hunting for an alternative at the exact moment Hermes’s releases were maturing. Whether Hermes holds the lead is an open question. Category leadership has now flipped once, and the same dynamics could flip it again.

Versus Claude Code (and Codex, and Cursor). Different species. Coding agents are session-based power tools, brilliant inside a repository and gone when you close them. Hermes is persistent and ambient, weaker as a pure coding instrument and unmatched at being around all the time, remembering everything, and handling the recurring stuff. For most professionals the answer isn’t either/or. It’s a coding agent in the editor and Hermes running the background of your work life. Both speak the same SKILL.md standard, so procedures can travel between them.

Versus ChatGPT, Claude, or Gemini as your daily assistant. The hosted assistants are easier, safer out of the box, and zero-maintenance, and their memory features keep improving. What they can’t offer is the combination Hermes is built on: your data on your infrastructure, any model you choose, an agent that initiates contact on a schedule, and deep, inspectable customization. Its entire personality is a markdown file you can edit. The trade is sovereignty and capability in exchange for setup and responsibility. For a lot of professionals that trade just became worth it. For many others it sensibly isn’t yet.

Real usage clusters into three patterns: the agent lives in your messaging apps, runs on a schedule, and compounds through memory and skills. Here are ten concrete workflows drawn from the community and the official user stories, translated where useful into PM terms.

1. The morning briefing. The canonical first automation. Every weekday at 8am the agent searches your space, whether that’s competitors, your category on Product Hunt, or relevant subreddits, and texts you a three-story summary with links before you open your laptop.

2. The inbox digest. Hermes reads overnight email, extracts action items, and delivers a clean triage to Telegram or WhatsApp. The most popular scheduled job in the ecosystem, for obvious reasons.

3. Competitive intelligence on a loop. Weekly crawls of competitor changelogs, pricing pages, and release notes, diffed against last week’s run and summarized as what actually changed. Because the agent remembers previous runs, it reports deltas, not dumps.

4. The feedback synthesizer. Pipe in support tickets, app-store reviews, or sales-call notes on a schedule, and get back recurring themes, severity ranking, and suggested roadmap implications. Save the procedure as a skill and the format stays consistent forever.

5. The voice-consistent writer. After a few drafting sessions, have the agent save a “write in my voice” skill. Every future LinkedIn post, launch note, or stakeholder update starts from your calibrated style instead of a blank prompt.

6. The research-to-brief pipeline. Hand it a topic Friday. It researches over the weekend, drafts a structured brief, and delivers it Monday. Several users run this as a standing weekly job.

7. The standup ghostwriter. For PMs near engineering: a scheduled job summarizes the repo’s merged PRs and open issues into a daily digest posted to a team channel.

8. The site monitor. Every fifteen minutes, check that the product’s critical pages respond, and alert the on-call channel with diagnostics if anything fails. Unsexy, valuable.

9. The demo-day concierge. One user told their agent to research them online and build a personal landing page. It ran the searches, generated the page, deployed it to a server, and sent a text when the page was live. The generalizable version: end-to-end micro-projects (”research X, produce Y, ship it to Z, tell me when done”) instead of single prompts.

10. The shared team assistant. A single Hermes instance in a team Slack or Telegram channel, with per-user authorization, answering questions, running lookups, and posting its scheduled reports where everyone sees them. The same pattern works at home. One well-known community setup is a family WhatsApp assistant serving three people from one agent.

Start with exactly one. The community’s hard-won advice is to get a single routine working reliably, and the briefing is the classic, before layering on the next. Automating everything in week one produces a fragile mess. One dependable loop produces trust, and trust is what makes you delegate more.

You should care about Hermes for two reasons, and only one of them is personal productivity.

The obvious reason: for the cost of a streaming subscription and an afternoon of setup, a professional in 2026 can have an always-on agent that remembers their work, watches their market, drafts in their voice, and texts them first. That capability used to be called a chief of staff, and it used to require headcount.

The less obvious reason is what Hermes demonstrates about building AI products. Nearly every notable decision in it is a product decision, not a model decision. Memory is made small so it stays curated. Recall is made free so it can be vast. Procedures are made portable by betting on an open standard. Distribution comes from living inside messaging apps users already have open. Monetization sits on convenience, the bundled gateway, rather than the software. And switching costs are built from an accumulating relationship rather than a lock-in contract. The model underneath is interchangeable by design. The durable value is the harness around it.

That’s the pattern to internalize, whatever you’re building. In the agent era, models are increasingly commodity inputs. Memory, trust, distribution, and compounding personalization are the product.

Hermes Agent is open source (MIT) at github.com/NousResearch/hermes-agent, with documentation at hermes-agent.nousresearch.com. Facts and figures in this piece reflect early June 2026. This category moves weekly, so verify current versions and pricing before standardizing on anything.