Hermes Agent Getting Started Guide: Persistent Memory and Sub-agents in Practice

Most so-called "AI agents" are, at the end of the day, just chatbots with a few extra steps bolted on. Hermes Agent from Nous Research tries to be different: it's an open-source, self-hosted agent framework with built-in persistent memory, scheduled tasks, parallel sub-agents, and a plugin system—extensible without forking the codebase.

This article focuses on three things: what Hermes can do for you, how to get it running fast, and where the fundamental difference lies between it and an ordinary chat assistant.

What Hermes Agent Is

Hermes is a self-hosted agent that continuously maintains a model of you and your environment. It can run terminal commands, edit files, browse the web, search its own conversation history, schedule tasks on timers, and spawn parallel sub-agents.

The same agent can respond to you in the terminal, on Telegram, Discord, Slack, or email—using the same memory and tools across every platform. This is the key differentiator: most chat tools start from scratch every conversation, while Hermes remembers your preferences, your projects, and what it has learned.

Self-hosted agent refers to an agent whose runtime, memory files, tool configuration, and model calls all run on the user's own machine or server, rather than being hosted in a vendor's cloud. This contrasts with SaaS-style assistants like ChatGPT and Claude: the latter are operated centrally by the vendor, users can only interact through an interface, and the underlying state cannot be inspected or migrated. The core benefit of self-hosting is data sovereignty—conversation history, memory files, and skill documents stay local and never become vendor training data. It also means the user must bear the runtime environment (an always-on machine or VPS), model API costs, and upgrade maintenance. For developers who value privacy and want to accumulate private context over the long term, self-hosting is the precondition for making the agent truly "their own."

Two-Minute Quick Start

On Linux, macOS, or WSL:

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

On native Windows (PowerShell):

iex (irm https://hermes-agent.nousresearch.com/install.ps1)
hermes

Once installation completes, you drop into an interactive chat. A few commands are worth remembering:

• hermes model — Select the LLM provider and model
• hermes setup — Full setup wizard (configuration, tools, messaging platforms)
• hermes doctor — Diagnose installation or configuration problems
• hermes update — Pull the latest version

If you installed the CLI but want to use the desktop app, just run hermes desktop.

Four Features That Actually Matter

Persistent Memory

Hermes maintains a curated memory file that persists across all sessions. Tell it once "I use a Mac and deploy on Cloudflare," and it won't forget. It can also search its own past sessions—ask it to recall something discussed weeks ago, and it can dig it up. This is the key to turning a tool that needs its background re-explained every day into a system that accumulates context over time.

Skills: The Self-Improvement Loop

Skills are small documents that encode procedures like "how I do X in this environment," and the agent loads the matching document when a relevant task comes up. More importantly: when Hermes figures out a non-trivial workflow, it can save that method as a skill for direct reuse next time. This is a genuine learning loop—the more you use it, the more proficient it becomes at specific recurring tasks.

Agent Skills as a concept has taken shape in recent years across products like Anthropic Claude Skills and OpenAI's custom tools. The idea is to extract procedural knowledge about "how to complete a certain class of task" out of model weights and into readable, editable, version-controllable documents or code snippets. Hermes' approach stores skills as local Markdown or structured files, and the agent loads them on demand based on task relevance during inference, avoiding stuffing every instruction into the context at once. This "retrieve on demand + write back" design gives the agent the ability to accumulate continuously: a useful skill can be distributed and reused across a team or community, and it can also be authored and refined by the agent itself, forming an external memory layer resembling a "knowledge base of experience."

Cron Scheduled Tasks

You can have the agent run on a timer—for example, "check these things every morning at 6am and send the summary to Telegram." Tasks can be agent-driven (it decides how to do it) or pure scripts (run this, and only notify me if the output changes). This is how you turn Hermes into a night-shift worker rather than something that requires you sitting in front of it.

Sub-agent Delegation

Faced with a big task, Hermes can spawn isolated sub-agents, each with its own context and tools, running in parallel and then reporting back. Three run concurrently by default. It's the equivalent of going from a slow single-threaded conversation to a team of workers: one researches, one drafts, one reviews—and you only see the final result.

Sub-agent delegation borrows from the "orchestrator–worker" pattern in multi-agent systems. The main agent acts as the orchestrator, splitting a large task into parallelizable subtasks, assigning each sub-agent an independent context window and a restricted toolset, letting them execute in parallel and then collecting the results. Compared with single-threaded sequential execution, this architecture can significantly cut latency and isolate irrelevant context, avoiding the "context pollution" that long conversations cause. Common industry implementations include AutoGPT-style task queues, LangGraph's supervisor pattern, and Claude's sub-agent tool. The cost is multiplied token consumption, plus the need for the main agent to have reliable decomposition and aggregation capabilities—otherwise subtasks tend to go off track or produce conflicting results.

Real-World Use Cases

• Personal automation — Morning briefings, nightly backups, "monitor this price and tell me when it drops"
• Self-hosted assistant — Access the same agent from your phone via Telegram or WhatsApp
• Developer workflows — Read code, run tests, open PRs, and remember your repo's conventions
• Multi-agent deployments — A fleet of agents with isolated configurations and shared skills, serving larger projects

What to Watch Out For When Running It Seriously

Hermes is free and open-source, but if you want it running 24/7, it still needs a home—an always-on machine, a VPS, or a container. Personal use mostly lives on a home machine; teams run it on a small server. The original article recommends a cheap VPS, starting at a few dollars a month.

One rule must be kept in mind: the memory and skill files belong to you, stored on your machine, and you must back them up. They are the truly irreplaceable part of Hermes.

VPS (Virtual Private Server) is an independent virtual machine carved out of a physical machine by a cloud provider through virtualization, with its own operating system, storage, and public IP, typically billed hourly or monthly. For an agent like Hermes that needs to be resident 24/7 and occasionally perform network tasks (browsing the web, receiving callbacks from messaging platforms), a VPS is a more reliable home than a home machine. Common choices include Hetzner, DigitalOcean, Vultr, and Oracle Cloud's free tier; an entry-level configuration of 1 core and 1GB of RAM at a few dollars a month is enough for personal use. Deployment usually involves hosting it with Docker or a systemd daemon, paired with tmux, an Nginx reverse proxy, and automated backup scripts. One thing to be aware of: once an agent on a VPS has terminal and file write permissions, you've effectively handed part of the control of a networked machine to an LLM. So strictly limit the commands it can execute, isolate sensitive credentials, and enable log auditing.

Conclusion

If what you want is a chatbot, Hermes gives you more. If what you want is an agent that truly "does things"—runs commands, schedules itself, remembers you, learns your workflows—this is one of the most complete open-source options available today. Start with the two-minute install, point it at one real recurring task, and let the skills and memory accumulate. That's the turning point where it goes from "a tool" to "something that works for you."

One-line Summary

Hermes Agent is an open-source self-hosted agent framework that stands apart from ordinary chatbots with persistent memory, skills, scheduled tasks, and sub-agents.

Paragraph Summary

Hermes Agent is an open-source self-hosted agent framework from Nous Research, aiming to turn "a chatbot with a few extra steps" into an agent that genuinely does things and accumulates knowledge. It works across the terminal, Telegram, Discord, Slack, and email with the same set of memory and tools, and through four core features—persistent memory, the Skills self-improvement loop, Cron scheduled tasks, and parallel sub-agent delegation—it upgrades a tool that starts from zero every conversation into a work system that grows over time. Installation is extremely simple: one curl script on Linux/macOS/WSL or one PowerShell line on Windows gets you chatting in about two minutes. It suits personal automation, developer workflows, self-hosted assistants, and multi-agent deployments. To run it 24/7, you need an always-on machine or VPS, and you must back up your local memory and skill files regularly.