Hermes Agent Explained: What Makes It Different

Most of us rent access to AI.

We open a website or an app. The company behind it chooses which models we can use, where our conversations and memory live, which tools are available and what the service will cost next month.

That may be completely fine. It is also easy to mistake the service for the AI itself.

Hermes Agent starts from a different idea:

What if the AI system ran on your own computer or server, and the model was only one replaceable part inside it?

That is where Hermes becomes interesting.

Hermes is not another AI model

Hermes Agent is open-source software built by Nous Research and released under the MIT licence.

It is not a model competing with GPT, Claude, Gemini, DeepSeek, GLM or Kimi. Hermes connects to those models and gives them a place to work.

The model provides the language and reasoning.

Hermes provides the surrounding system:

• Memory that survives between sessions.
• Tools that let the model interact with files, APIs and software.
• Skills that describe repeatable ways of working.
• Profiles with separate roles, models and memories.
• Scheduled work that can start without you opening a chat.
• Connections to messaging platforms and external services.
• Approval controls for potentially dangerous actions.
• A record of what happened.

Nous calls Hermes a self-improving AI agent. I find it easier to understand as an agent operating layer.

It runs on your machine

This is one of the most important differences.

Hermes can run on your laptop, desktop computer, home server or private cloud server. Its conversations, sessions, built-in memory and skills are stored locally under its own data directory.

According to the official documentation, Hermes does not collect telemetry, usage analytics or copies of your conversations. API calls go only to the model provider you configure.

That gives you more control over your data than a system that exists entirely inside somebody else's platform.

But "local" can mean two different things.

Local system, hosted model

Hermes runs on your machine and stores its memory, skills, sessions and configuration there.

When it needs intelligence, it sends the necessary information to a hosted model provider. That could be OpenRouter, Nous Portal, Anthropic, OpenAI, Google or another service.

In this configuration, your long-term agent state remains on your machine, but the model still processes prompts in the cloud.

This is locally controlled, but not completely private.

The provider receives whatever context Hermes sends for that request. Its privacy, retention and data-processing rules still matter.

Local system, local model

Hermes can also connect to a model running on the same machine or inside your own network through software such as Ollama or vLLM.

In that configuration, the agent and the model can both run on infrastructure you control. There is no model API key, no model subscription and no need to send the conversation to an external inference provider. Hermes provides an official guide for running entirely locally with Ollama.

That can be valuable when working with private company information, family data, internal documents, source code or anything else you do not want to send to a commercial AI provider.

It does not make every action invisible to the outside world. If the agent searches the web, sends a message, reads email or calls another external service, data still crosses that boundary.

A fully local model is also not free in the practical sense. You need sufficient memory, storage and often a capable GPU. Smaller local models may struggle with complicated reasoning or reliable tool use.

The point is not that local is always better.

The point is that Hermes gives you the choice.

One system, many models

A normal hosted AI product gives you models from one company.

Hermes can work with models from many companies, along with open models running on your own hardware. Its provider system supports cloud services, local models and custom compatible endpoints.

This means you do not need to use the same model for every job.

You might use:

• A smaller, lower-cost model for summaries and routine checks.
• DeepSeek, GLM or Kimi for capable but potentially cheaper general work.
• A stronger model for difficult reasoning or critical reviews.
• A local model when privacy matters more than maximum performance.
• A backup model when the main provider is unavailable.

Hermes also lets you assign smaller models to background jobs instead of using the most expensive model for everything.

The agent's memory, skills and configuration remain in Hermes. Changing the model does not mean starting the entire system again.

That reduces dependence on one provider.

If a model becomes too expensive, changes its rules, disappears from a subscription or is replaced by something better, you can move to another one without rebuilding the agent's identity and procedures from zero.

Cheaper models are useful, but not automatically cheaper

A model with a lower price per token can still become expensive if it repeatedly misunderstands a task.

This matters more for agents than for ordinary chat.

An agent may need to:

• Understand the goal.
• Choose the correct tool.
• Provide valid parameters.
• Inspect the result.
• Notice when something failed.
• Decide what to do next.

A weaker model might call the wrong tool, get stuck in a loop or confidently claim that work succeeded when it did not.

For a simple morning summary, that risk may be acceptable.

For changing production infrastructure or contacting a customer, it is not.

The sensible rule is: use the least expensive model that can complete this specific task reliably.

Hermes gives you the freedom to make that choice per task, profile or background function.

It does not remove the need to test the result.

Several models can work on the same problem

Hermes includes a feature called Mixture of Agents, or MoA.

The basic idea is simple.

Imagine that you have a difficult decision. Instead of asking one person, you ask several people with different backgrounds. Each examines the problem independently. Their findings then go to one final person who compares the perspectives and produces the answer.

Hermes can do something similar with models.

You configure one or more reference models and one aggregator model.

The reference models examine the task first. The aggregator receives their analyses, creates the final response and remains responsible for any tool calls.

The models can come from different providers.

For example:

• One model checks the technical reasoning.
• Another looks for business risks.
• A third challenges the assumptions.
• The aggregator combines the findings into one recommendation.

This is not necessary for everyday work. Asking four models to improve a short email would waste time and money.

MoA becomes interesting for work where another perspective has real value: research, architecture, strategy, complex debugging or decisions that would be expensive to reverse.

It also does not guarantee truth. Multiple models can repeat the same incorrect information, and the aggregator can still make a poor decision.

Profiles are more than personalities

Hermes lets you run multiple profiles on the same machine.

A profile is not simply an assistant with a different name or tone.

Each profile can have its own:

• Model and provider.
• Memory and conversation history.
• Skills and instructions.
• Tools and integrations.
• API credentials.
• Scheduled jobs.
• Security configuration.

One profile could be a researcher that uses web search but cannot modify files.

Another could be a developer with access to repositories and a strong coding model.

A third could handle routine operations using a cheaper model.

These are separate, persistent agent environments.

Hermes can also create temporary subagents for parts of a larger task. A research agent might delegate several independent questions, collect the findings and then continue with the complete picture.

The distinction is useful:

• A profile is a long-term agent setup.
• A skill is a reusable procedure.
• A subagent is a temporary worker for part of a task.
• MoA uses several models to examine the same problem.

Skills are how the system preserves a good process

A skill tells the agent how to perform a particular kind of work.

It could explain how to:

• Prepare a client brief.
• Review a pull request.
• Investigate a failed deployment.
• Check an article before publication.
• Close a working day and preserve the open decisions.
• Qualify an incoming prospect.

Hermes skills are stored as local, inspectable files. They may include instructions, scripts, templates and reference material.

This matters because a useful process no longer needs to remain trapped inside an old conversation.

After completing a complicated task, Hermes can turn what worked into a reusable skill. The next time the same situation appears, the agent can load that procedure rather than improvising everything again.

That is part of what Nous Research means by "self-improving."

The agent is not rewriting its own intelligence. It is preserving procedures and lessons from previous work.

It can still preserve the wrong lesson. Generated skills can become outdated, duplicated or unnecessarily complicated. They need review, just like any other operating procedure.

The valuable part is that you can open the file and see what the agent is being told to do.

Honcho: memory that learns how you work

Hermes includes a memory layer called Honcho. It tracks patterns, preferences and facts across sessions. Not chat history. Behavioral memory. It learns how you work, not just what you said.

Honcho can run self-hosted on your own infrastructure, which means your agent's long-term memory does not need to live inside a third-party platform. For anyone who has watched a chatbot forget everything important on day one, this is the part that changes the math.

Could a mainstream AI service do this?

Many individual parts, yes.

The largest AI platforms now offer combinations of project memory, specialist agents, reusable skills, connected apps and scheduled tasks. ChatGPT Workspace Agents, Claude Cowork and Gemini Spark are all moving in this direction.

For most people, one of those services will be easier.

You create an account, pay the subscription and use the interface. The provider maintains the infrastructure, deploys the updates and handles much of the security.

Hermes asks more from you.

You operate the software. You are responsible for updates, backups, credentials, model costs and permissions. If the system is exposed incorrectly or given excessive access, that becomes your problem.

The difference is control.

Hosted AI service — the provider chooses the available model family.

Hermes — you choose the provider and model.

Hosted AI service — memory and configuration live in the provider's platform.

Hermes — core memory, skills and sessions remain local.

Hosted AI service — scheduled work runs in the provider's cloud.

Hermes — scheduled work runs on infrastructure you control.

Hosted AI service — you use the integrations the provider supports.

Hermes — you can add tools, plugins, APIs and MCP servers.

Hosted AI service — the service hides most operational complexity.

Hermes — you are responsible for operating the system.

Hosted AI service — easier to begin.

Hermes — more flexible, but more work.

Hermes is not a replacement everyone needs.

It is an alternative for people who want to own more of the system.

What makes Hermes different

There is no single Hermes feature that nobody else can reproduce.

What makes it different is the combination:

• The software is open source.
• The operating layer runs on your infrastructure.
• Conversations, memory and skills are stored locally.
• Hermes itself does not collect usage telemetry.
• You can run the model locally for a much stronger level of privacy.
• You can use models from competing companies.
• Different work can use different models and prices.
• Several model families can contribute to one result.
• You can inspect and modify the procedures the agent follows.
• You can replace the model without replacing the entire agent system.

The important word is ownership.

You own the operating layer, even when you rent some of the intelligence from an external model provider.

Why this matters in Europe

If you run a business in Germany, Austria or Switzerland, data protection is not optional. GDPR is the floor, not the ceiling. German telemedia law, EU AI Act obligations, and client contracts add layers on top.

A hosted AI service in the US may be convenient. It also means your agent state, conversation history, and operating context live under US law, on infrastructure you cannot inspect, in a jurisdiction you cannot easily challenge.

Hermes does not solve all of that automatically. If you send prompts to a US model provider, that path still crosses the Atlantic. But the core: memory, skills, configuration, session history, scheduled jobs, stays on your machine. In your country. Under your law.

For a DACH business owner who must explain to a client where their data lives, that is not a nice-to-have. It is a requirement.

Why I use it

I still use hosted AI products. They are convenient, capable and often the correct tool for a specific task.

I use Hermes because I do not want my full working system to exist inside one of them.

I want the memory, procedures and operating structure to remain under my control. I want routine work to use less expensive models and difficult work to reach stronger ones. I want the option to run sensitive tasks locally. I want to compare different model families instead of assuming that one company always has the best answer.

Most importantly, I want to understand the system doing the work.

For someone who only wants a capable AI assistant, Hermes may be unnecessary.

For someone building a long-term agent system, particularly one that must balance privacy, cost, automation, model quality and independence, it becomes much more interesting.

I wrote about two working installs at different scales: one that runs my week alongside a full-time job, and one that runs a customer-facing chatbot on this website. Same tool. Same principle. Different scales.

How to start

You do not need my setup. You need a terminal and fifteen minutes.

After that:

Pick a provider. OpenRouter is simplest. Free tier available.

• Pick a model. Start small. DeepSeek or GLM 5.2 are cheap and fast. Upgrade later.
• Talk to it. The first conversation teaches it who you are. It remembers.
• Add one skill. The thing you repeat every week. A status update. A morning check.
• Schedule one job. A morning brief. An end of day close.

Full docs: hermes-agent.nousresearch.com/docs

Source code: github.com/nousresearch/hermes-agent

My setup

I run Hermes on a local Fedora 43 workstation with Sway Atomic. The Hermes runtime lives inside a Toolbx container, isolated from the rest of the system.

My websites and production services run on a separate Hetzner Cloud server in Germany. That server also hosts a self-hosted Honcho memory backend.

Hermes on the workstation. Production on the server. A hybrid setup: local control plane, remote infrastructure.

For a European operator, this matters. My agent state, memory, skills and session history sit on a machine in my office, under EU data protection law. My production infrastructure sits in a German data center, under the same legal framework. Not in a US cloud I cannot audit.

Hetzner is a German hosting company. The server costs about 23 euros per month for both sites plus production services. No cloud subscription. No per-seat pricing. No vendor lock-in.

This is the first piece in a series about the tools and setup that run my actual work. Next: a plain-language map of ChatGPT, Claude, Claude Code, Codex and Hermes, for anyone drowning in tools and trying to understand which layer actually solves their problem.

If you want to understand the AI landscape without the fog, these are a good place to start:

Which AI model should I actually use?

The AI landscape in one read

AI adoption is not about how many agents you run

Two AI bosses say we're in the singularity

If you want proof instead of slides:

What an owned AI operating layer looks like in production

How I fixed my chatbot

All work and case studies

The simplest explanation

Hermes is not another brain competing with GPT, Claude, Gemini, DeepSeek, GLM or Kimi.

It is the place where those brains can work.

You decide which one to use, what it can access, what it should remember, what procedures it should follow and whether any part of the work should leave your machine.

That is what makes Hermes Agent different.

Hermes Agent is built by Nous Research and released under the MIT licence. I use it, but I am not part of the Hermes team and have no commercial relationship with Nous Research.