Hermes AI Agents: The Complete Open-Source Guide

In AI circles, 'Hermes' used to mean one thing: the open-weight model family from Nous Research, beloved by local-model enthusiasts for tool calling and steerability. Since February 2026 it means two things: those models, and Hermes Agent — the MIT-licensed, self-hosted AI agent that Nous calls 'the agent that grows with you' and, on its own homepage, 'the most widely used open source agent harness in the world.'

The two are related but separable. Hermes Agent is the software that plans, remembers, schedules, and talks to you from Telegram or a terminal. The Hermes models (now in the Hermes 4 generation) are one family of 'brains' you can point it at — though the agent happily runs on models from OpenAI, OpenRouter, or anything else. That split is the heart of the story: an open harness that turns any capable model into a persistent, self-improving agent.

This guide covers both halves and how they fit together: where the Hermes models came from, what the agent actually does, how to install it in minutes, what hardware you need to run it locally, how its learning loop works, and where the whole thing falls short. If you have used a chatbot for a year and keep re-explaining your context every morning, this is the category of software that fixes that.

One naming note before we go deeper: Nous Research (also behind the Psyche decentralized training network and the Forge reasoning API) is not affiliated with other projects that share the Hermes name — including the Hermes JavaScript engine, which is unrelated. In this article, Hermes always means the Nous Research models and agent.

Closed agent platforms — the agent modes inside ChatGPT and Claude, and products like Manus — are genuinely good. They are also rented: your conversations, files, and accumulated memory live on someone else's servers; the model behind them can change overnight; pricing can change with it; and when you leave, your context does not come with you.

Open-weight agents flip each of those properties. The software is inspectable and modifiable (Hermes Agent is MIT-licensed, about as permissive as licenses get). The models can be downloaded and run offline, so sensitive material never has to leave your machine. And the memory layer — the part that actually makes an agent feel like yours — is a set of files you own and can back up, edit, or move.

The practical stakes are easiest to see at the two ends of the spectrum. A solo developer running an agent on a $5 VPS pays near-nothing for automation that would cost a seat license elsewhere. A business handling confidential documents can run the entire stack on its own hardware, which removes the question 'where does our data go?' from the procurement meeting entirely.

Open agents are not automatically better, and this guide will be honest about where they lag. But the category now has real momentum: hardware vendors ship guides for running these agents locally, and the open harnesses are evolving faster than most closed tools' release notes. If you have read our comparison of AI chatbots, think of this as the next layer up: not which chatbot to talk to, but which agent to hire — and whether it should live on your hardware.

One thing does not change between chatbots and agents: technique. A well-briefed agent outperforms a vaguely-briefed one by the same margin as ever, so the prompting patterns that work for chatbots carry over directly.

The Hermes models predate the agent by years, and their design priorities explain why local agent frameworks kept choosing them.

The fine-tune era (2023–2024). Nous Research built its reputation on community-driven fine-tunes — the OpenHermes lineage — that made small open models dramatically better at following instructions. Hermes 2 Pro (2024) was the turning point for agents: it introduced a first-class function-calling format built on the ChatML prompt structure, plus a JSON mode for structured output. Its convention — tool definitions as JSON schemas inside a tools block, calls emitted as tool_call payloads — became a de facto standard. Open-source inference servers such as vLLM ship a dedicated 'hermes' tool-call parser for it to this day.

<tools>
[{"type": "function", "function": {"name": "get_weather", "parameters": {...}}}]
</tools>

<tool_call>{"name": "get_weather", "arguments": {"city": "Oslo"}}</tool_call>

Hermes 3 (August 2024) scaled the recipe onto Llama 3.1 at 8B, 70B, and 405B parameters, with agentic function calling, strong long-context multi-turn behavior, and the 'neutrally aligned' steering philosophy — the model follows your system prompt rather than an imposed persona. For agent builders, that is the whole point: the agent's system prompt is the product, and it needs a model that does not fight it.

Hermes 4 (August 2025) added hybrid reasoning: the model can answer directly or think first in a visible reasoning block, and you can toggle which mode you want per request — cheap and fast for routine tool calls, deliberate for hard planning. The 14B variant is built on Qwen3-14B under Apache 2.0; the 70B and 405B variants build on Llama 3.1. All weights are published, and the accompanying technical report is unusually candid about training challenges.

Hermes-4.3-Seed-36B (December 2025) is the one to know if you follow open research: roughly Hermes-4-70B-level performance at half the size, post-trained entirely on the Psyche network — decentralized training as a production method, not a demo. Around the same time, Nous shipped Nomos 1, a 30B mathematics specialist built with Hillclimb, a reminder that the team now releases specialists alongside generalists.

For agent work, the takeaway is simple: from Hermes 2 Pro onward, tool calling, steerability, and structured output were first-class goals — not features bolted on later. That is why so many local agent stacks, Hermes Agent included, feel native on these models.

Strip away the branding and Hermes Agent is a harness: a program that connects a language model to tools, memory, and communication channels, then loops — plan, act, observe, adjust — until a task is done. What makes it notable is how complete the harness is for something you install with one command.

It runs where you want. The same install works on a laptop, a $5 VPS, or a GPU cluster, and seven terminal backends cover the realistic deployment range: local processes, Docker containers, SSH remotes, Singularity for HPC environments, and serverless sandboxes on Modal, Daytona, and Vercel Sandbox. The serverless options are the interesting ones — the agent's environment hibernates when idle and wakes on demand, so an always-available agent costs almost nothing between sessions.

It talks where you talk. A single gateway process connects Telegram, Discord, Slack, WhatsApp, Signal, Email, and Home Assistant, with voice memo transcription built in — send it an audio note and it transcribes and acts (our roundup of AI transcription tools covers standalone options if that is all you need). Cross-platform continuity means a conversation started on Telegram continues in the CLI.

It schedules. A built-in cron scheduler turns natural-language requests into unattended automations: 'every weekday at 8am, send me a brief on Telegram.' Delivery goes to any connected platform.

It parallelizes. For heavy jobs, it spawns isolated subagents for parallel workstreams, and you can write Python scripts that call its tools over RPC — collapsing multi-step pipelines into single turns that don't bloat the context window.

It extends. More than 40 built-in tools are grouped into configurable toolsets — file system, terminal, browser automation, and more — and any MCP (Model Context Protocol) server can be attached for capabilities the core does not ship. For researchers, there is batch trajectory generation and trajectory compression, aimed at training the next generation of tool-calling models — a reminder that Nous approaches agents as research infrastructure, not just consumer software.

A full terminal UI rounds it out: multiline editing, slash-command autocomplete, streaming tool output, and interrupt-and-redirect, so you can change an agent's course mid-task instead of waiting for it to finish something wrong.

The feature that separates Hermes Agent from most open harnesses is the learning loop — the repository describes it as the only agent with a built-in one. The loop has distinct memory layers, and they behave differently.

Curated memory (what it knows). The agent maintains persistent memory files and is periodically nudged to save what matters — decisions, preferences, project state. Crucially, the agent curates this itself: it decides what is worth persisting, and it can search its own memory later. You can open the files and edit them; they are plain Markdown.

Session search (what happened). Every conversation is indexed with full-text search, and the agent can query its own history with LLM summarization for cross-session recall. 'What did we decide about the database migration in March?' becomes a question the agent can actually answer, because it can look.

User modeling (who you are). A dialectic user model builds a deepening picture of your preferences and working style across sessions, so the agent's default behavior drifts toward what you actually want rather than what you last asked for.

Skills (how it works). The most distinctive layer is procedural: after completing a complex task, the agent can autonomously write a skill — a reusable procedure capturing how the task is done. Skills improve during use: when a procedure misfires, the agent can revise it. Skills live in a Skills Hub and follow the agentskills.io open standard, so they are portable and shareable.

The compounding effect is the point. A chatbot's competence resets to baseline every session. An agent with this loop starts week two ahead of week one: your morning brief gets sharper because last week's corrections were saved; your deploy checklist becomes a skill because it watched you do it. The honest caveat: the loop amplifies whatever model runs it. A weak model writes weak skills, and curated memory can curate the wrong things — treat skills and memory like code review, not gospel.

Installation is deliberately boring, which is a compliment for self-hosted software.

On Linux, macOS, or WSL2:

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

On native Windows (no WSL required) — in PowerShell:

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

The Windows installer sets up under your local app data folder and handles Python, Node.js, and the rest; there is also an MSIX/App Installer package if you prefer store-style updates, and a signed APT repository for Android via Termux. A desktop app for macOS and Windows covers everyone who does not want a terminal at all — a notable shift for a project that spent its first months as a terminal-first tool.

Then run hermes setup. The wizard walks through provider choice, model selection, and tool permissions; hermes setup --portal does it in one step if you want the Nous Portal subscription route. After that, hermes starts the interactive TUI and you are in a conversation.

Commands worth knowing on day one:

• hermes model — switch providers or models, no code changes.
• hermes tools — enable or disable toolsets; start conservative.
• hermes gateway — set up and start messaging integrations (Telegram, Discord, and so on).
• hermes doctor — diagnose installation and configuration problems.
• hermes update — the project moves fast; update weekly.

Coming from OpenClaw? hermes claw migrate imports its persona file, memories, skills, messaging settings, and API keys, with a dry-run mode to preview what moves. That migration path tells you something about the market: these harnesses expect to be evaluated against each other, and switching costs are meant to be low.

Because the harness is model-agnostic, the biggest decision you make is not whether to use Hermes — it is which model to plug in. There are four realistic routes.

Nous Portal (one subscription, everything included). Nous sells a single subscription that covers 300+ models plus a Tool Gateway: web search, image generation, text-to-speech, and a cloud browser, all routed through the same account. The point is not lock-in but convenience — five separate API keys collapse into one, and hermes setup --portal wires it up via OAuth. Per-tool overrides remain possible, so the gateway is a default, not a cage.

OpenRouter (one key, every provider). If you want to route across model vendors without subscriptions, OpenRouter gives you a single API key for most of the market. Hermes connects directly; you pay per token and can swap models per task.

Direct provider APIs. Point Hermes at OpenAI or any Anthropic-compatible endpoint you already pay for. This is the route for people who want frontier models for hard planning and nothing else to change.

Local models (zero marginal cost). Ollama, LM Studio, llama.cpp, or vLLM on your own hardware. Nothing leaves your machine and there is no per-query bill; the trade is setup effort and a quality ceiling. Reviewers have called the Hermes-with-Ollama pairing a favorite precisely because the pieces are designed for each other.

Which Hermes model should be the brain? A rough guide: Hermes 4 14B for laptops and quick tool-calling; Hermes-4.3-Seed-36B as the sweet spot when you have a serious GPU — it approaches the 70B's capability at half the size; Hermes 4 70B for workstations; and 405B via API for the hardest tasks. Nomos 1 exists for heavy math, not general agent work.

Two practical notes. First, tool-calling reliability varies by model — the agent's own hermes tools test command exists because a model that chats beautifully can still fumble structured calls. Second, if your question is which closed brain to compare against, our ten-task benchmark of major AI chatbots gives you reference points from the rented side of the fence.

Running the brain locally is where open agents get real. The core trade is quantization: compressing model weights from 16-bit to 8-bit or 4-bit shrinks memory needs dramatically at a modest quality cost. Formats: GGUF for llama.cpp and LM Studio, MLX for Apple Silicon, FP8 for datacenter GPUs. The table below lists approximate memory needs at 4-bit quantization for the current Hermes generation.

Model

Base

Memory (4-bit)

Realistic hardware

Hermes 4 14B

Qwen3-14B

~8–10 GB

RTX 3060 12GB; 16GB Mac

Hermes 4 14B (8-bit)

Qwen3-14B

~15–16 GB

RTX 4080; 24GB Mac; near-full quality

Hermes-4.3-Seed-36B

—

~20–24 GB

RTX 4090; 32GB+ unified memory

Hermes 4 70B

Llama 3.1

~40–45 GB

2×24GB GPUs; 64GB Mac Studio

Hermes 4 405B

Llama 3.1

200 GB+

Multi-GPU server — or just use the API

Two costs beyond weights: context memory (the KV cache grows with conversation length, so long agent sessions eat RAM), and speed (tokens per second falls as models grow; a 14B on a gaming GPU feels snappy, a 70B on the same card will not run at all).

The hardware industry has noticed this category. NVIDIA published guides for running self-improving agents on RTX PCs and DGX Spark, and AMD followed with Ryzen AI Max+ and Radeon instructions — local agents are becoming first-class workloads, not hobbyist experiments.

Honest expectations: a 14B or 36B local model is excellent for routine agent work — scheduling, summarizing, drafting, tool orchestration — but it does not match frontier closed models on the hardest reasoning, and pretending otherwise leads to disappointment. The pragmatic setup many people land on is hybrid: a local model for private, high-volume, routine work; a cloud model a slash command away for the genuinely hard problems.

Abstract capabilities are cheap; here is what the loop feels like in practice. Suppose you want a weekday morning brief in Telegram: calendar, unread priorities, weather, and open issues on your main repository — delivered at 8am, before you are at a desk.

Setup is conversational. After installing and connecting the Telegram gateway (hermes gateway setup), you ask the agent to build the brief. It checks which tools it needs (calendar access, web search, a code host integration, the messaging channel), enables them with your approval, and produces a first version. Then the loop does its work:

1. Day one: you critique the output — 'the weather line should be first and one sentence; skip issues labeled backlog.'
2. Day two: the agent has persisted those preferences and edits the procedure. When you ask it to formalize what it just did, it writes a morning-brief skill.
3. Week two: the brief runs unattended on the cron scheduler; when you add a second repository, you say so once, and the skill updates.

The same pattern handles less glamorous work: a nightly backup summary, a weekly audit of expiring subscriptions, a voice memo from your phone that becomes action items (the transcription happens inside the gateway). Because skills are files following an open standard, you can inspect them, fix them, or copy them between installations.

For parallelizable jobs, the subagent system shines: 'audit every page on my site for broken links and outdated claims' fans out into isolated workers, each with its own context, reporting back to the parent. You are not writing code for any of this; you are delegating, reviewing, and correcting — which is exactly the skill the agentic era rewards.

For many buyers, the privacy argument alone justifies the open route. Organizations can run Hermes Agent on their own infrastructure, which reduces the need to send proprietary source code, documents, or other confidential data to third-party AI providers. The data path has three shapes, and each buys a different amount of control:

• Fully local (agent + model on your machine): nothing leaves your hardware. The memory files, the conversations, and the inference all stay home.
• Hybrid (local agent, cloud model): the agent and its memory live with you; model calls go out. Convenient, but the model provider sees what it processes — the same consideration as any AI privacy decision.
• Self-hosted server (VPS or homelab): your always-on agent and its gateway live on infrastructure you control, reachable from your phone but owned by you.

Hermes adds guardrails at the layer that matters most — what the agent can do: command approval prompts before risky actions, DM pairing so only your accounts can command the bot, and container isolation through the Docker backend so a runaway process stays inside a box you can delete. That last one deserves emphasis: an agent with terminal access is a powerful program, and the sandbox is not optional decoration.

The honest flip side: self-hosting shifts responsibility to you. You patch the agent and the model runtime; you secure the VPS; you treat messaging tokens and API keys as the credentials they are. If nobody on your side wants that job, a closed platform's compliance program is a feature, not a weakness. Open agents trade that program for control — decide which you actually want.

So how does the open stack compare, plainly? Scores vary by task and month, but the structural differences are stable.

Dimension

Hermes Agent (open)

Closed platforms (ChatGPT agent / Claude / Manus class)

Cost

Free software; pay for hardware or tokens only

Subscription per seat; usage caps

Data path

Your hardware; fully local possible

Vendor cloud by design

Model choice

Any provider, any local model, swap anytime

Whatever the vendor serves

Memory & skills

Files you own; portable, inspectable

Vendor-hosted; export limited or none

Setup

Install + configuration (minutes to hours)

Sign in and go

Peak capability

Depends on model chosen; below frontier on hardest reasoning

Frontier models, tuned end to end

Extensibility

MCP servers, custom tools, subagents, open skills standard

Vendor plugin ecosystems

Lock-in

None — MIT code, open formats

Real, and priced accordingly

Read the table honestly: closed platforms win the rows that matter to most people on day one — setup and peak capability. The frontier models behind the big platforms are still stronger on the hardest reasoning, and their agent harnesses are tuned around those models with enormous engineering budgets.

Where open wins is everything that accumulates over time: cost at volume, data control, memory you can take with you, and the freedom to change models when something better ships. The closed-side benchmark is worth reading as a ceiling reference: pick the closed tool whose strengths match your weak categories, then decide how much of that you would trade for ownership.

A final structural note: within the open category, the race is not about raw model quality but about memory and learning. Coverage of the OpenClaw-versus-Hermes rivalry has framed it exactly that way — a race to build assistants that never forget — and Hermes's learning loop is its opening argument. Migration between open harnesses is cheap; migration out of a closed platform usually is not.

No honest guide skips the failure modes. Here is where Hermes — the models and the agent — currently disappoints.

• You are the sysadmin. Updates, model management, VPS security, gateway tokens: the operational burden that closed platforms hide is yours. The project's hermes doctor command and frequent releases help, but the job does not disappear.
• The quality ceiling is real. Local 14B and 36B models handle routine work well and hard reasoning less well; even 405B sits below the strongest closed models on the most demanding tasks. If your work lives at that frontier, the open stack is not yet your daily driver.
• Tool-calling quirks happen. Community reports describe models occasionally emitting tool calls as plain text instead of structured payloads, depending on provider and version. Harnesses work around this, but it is a reminder that open stacks are composed of moving parts you assemble yourself.
• The learning loop can learn the wrong things. Autonomous skill creation and curated memory are powerful exactly because they are autonomous — which means mediocre skills and stale memories accumulate unless you review them periodically. The files are readable; read them.
• General-purpose, not specialized. For pure coding, IDE-native agents remain more integrated than any general harness. Hermes can drive a terminal and edit files, but if your entire job is inside one editor, a coding agent fits that loop better.
• No managed cloud from Nous itself. Community deployment guides exist for platforms like Railway, but there is no official hosted Hermes. You run it, or it does not run.

None of these are disqualifying, and most shrink with every release. But they define the persona this software is for: someone who wants control enough to accept responsibility. If your eyes glaze at the word 'container', close the tab and subscribe to something; that is a legitimate answer.

Step back from one product and the pattern is bigger. Hermes Agent now appears in encyclopedic lists of general-purpose AI agents alongside ChatGPT's agent mode, Manus, and OpenClaw — a category that barely existed two years ago. Three currents are worth watching.

Standards are forming fast. Anthropic's Model Context Protocol has become the default way to attach tools, and Hermes speaks it. Skills follow the agentskills.io open standard. Agent-to-agent protocols are emerging for multi-agent systems. Each standard lowers the cost of switching harnesses, which disciplines every vendor in the space — including the closed ones.

The hardware ecosystem has adopted local agents. When NVIDIA and AMD publish official guides for running a specific open agent on their consumer hardware, that is mainstream adoption by any reasonable definition. Local agents moved from hobbyist forums to vendor marketing pages in under a year.

Open AI research now ships at production pace. Nous Research's own trajectory tells the story: Hermes 4's hybrid reasoning in August 2025, the Psyche-trained Hermes-4.3-Seed-36B in December 2025, the agent harness in February 2026, and reports of funding talks at a $1.5 billion valuation by mid-2026. Whether or not that round lands at that number, the signal is clear: open-weight AI and open agent infrastructure are attracting serious capital.

For users, the practical meaning is optionality. The agent you build on Hermes files today — its skills, its memory files, its automations — is built on open formats, so it survives vendor pivots, shutdowns, and pricing changes. In a category this young, optionality is not a nice-to-have; it is the difference between owning your workflow and renting it.

Strip everything else away and the decision comes down to fit. Hermes — models plus agent — is the right build when several of these describe you:

• Privacy is non-negotiable. You handle confidential client documents, health or legal material, or proprietary code, and 'the vendor's cloud' is not an acceptable home for it.
• You are automation-hungry. You want scheduled briefs, monitored inboxes, nightly audits — recurring work that a stateless chatbot cannot hold onto.
• You tinker productively. You enjoy reading config files, trying models, and treating your tools as a garden rather than an appliance.
• Cost scales with your volume. You run enough queries that per-seat subscriptions or per-token bills at closed prices sting, and you have — or will buy — hardware that amortizes.

And it is the wrong build when the mirror image holds: you want software that works in five minutes with zero maintenance, you need the absolute frontier on every task, or your entire workflow is one IDE where a coding agent already lives.

If you are curious but cautious, start small and honest: install on your own machine, connect a cheap cloud model through the portal or OpenRouter first, and automate exactly one recurring task — a morning brief is the classic. Watch whether the learning loop actually saves you re-briefing. Add a local model when you have a privacy reason or a volume reason. Keep a frontier cloud model a slash command away for the hard problems.

The deeper point of the Hermes story is not that it beats ChatGPT — on many days, for many tasks, it does not. It is that the agent era now has an open pillar with real momentum: free software you can inspect, models you can own, memory that compounds on your hardware, and an exit that costs nothing. For enough people, that is not the alternative to the future of AI agents. It is the future of AI agents.

Wherever you land, the fundamentals still apply: clear briefs, verification discipline, and knowing each tool's weak categories — the same habits our guide to effective AI chatbot use teaches. Agents amplify good technique and bad alike; the loop that learns from your corrections also learns from your sloppiness.