Hermes Agent is the open-source self-improving agent from Nous Research. It keeps memory across restarts and writes its own reusable skills, which is what makes it valuable and also what makes reviewing it a real job.
Hermes Agent is an open-source autonomous agent from Nous Research, released under the MIT licence in February 2026. It runs on your own server and reaches you through messaging platforms such as Telegram, Slack, Discord, and WhatsApp. What separates it from a stateless assistant is that it keeps persistent memory across restarts and creates its own reusable skills from work it has completed, so it changes over time rather than starting fresh each session.
Self-improving: it saves successful approaches as reusable skills and refines them through use
Persistent: memory of preferences, corrections, and completed work survives restarts
Reachable through messaging: one gateway across Telegram, Slack, Discord, WhatsApp, Signal, and more
Bring your own model: Nous Portal, OpenRouter, Anthropic, OpenAI, or any OpenAI-compatible endpoint
Self-hosted by default: memory, skills, and conversation history live on your machine, though prompts still go to whichever model provider you configure
THE SETUP GUIDE
Most agent advice assumes the agent is the same on day ninety as on day one. Hermes is not, by design. That changes what you have to watch: the install is easy, and the ongoing work is reviewing what it has learned.
A modest VPS is enough to start, and Docker is the supported path. What it will not tolerate is a machine that sleeps, because an agent reached through chat is only useful while it is listening.
Hermes expects a model with a large context window, so the model you choose constrains it more than the server does. Confirm the model meets the documented minimum before sizing anything else.
It reaches real systems through real keys. Give each integration its own credential with the narrowest permission that works, and treat every connected key as something the agent will eventually exercise.
The agent can create and update its own skills, which are scripts it will run again later. That is the feature, and it is also the reason someone has to read them. A skill written from one lucky success becomes a habit.
Corrections and preferences persist. A wrong fact accepted early keeps being applied, quietly, long after anyone remembers teaching it. Read what it has stored on a schedule and remove what is wrong.
Watch it propose actions before it takes them, allow reversible actions next, and keep anything irreversible behind approval. Early sessions shape the memory that everything later is built on, so it is worth being patient exactly when it feels slowest.
These are the failures worth designing against before they happen, rather than diagnosing afterwards.
Never reading the skills it wrote for itself, so a bad approach becomes permanent
Correcting it carelessly early, because those corrections persist and compound
Connecting one broad credential instead of scoped per-integration keys
No spend limit, so a loop against a failing dependency runs up cost overnight
Assuming a chat interface means low stakes, when the agent is executing on real systems
Backing up the container but not the memory and skill store, which is the part that took months to build
We set up Hermes Agent on infrastructure you own, wire it to the channels your team already uses, and put the credential scoping, review cadence, and monitoring in place from the start.
Talk through your setupHost provisioning, Docker deployment, and hardening
Model and provider selection against the context requirement
Messaging channel setup and access control
Scoped credentials per connected integration
A review cadence for stored memory and self-written skills
Backups covering the memory and skill store, not just the container
Spend limits, logging, failure alerting, and documented handover
An open-source autonomous agent from Nous Research, MIT licensed and released in February 2026. It runs on your own hardware, reaches you through messaging platforms, and differs from a stateless assistant by keeping persistent memory and writing its own reusable skills from completed work.
When the agent works out a non-trivial approach, it can save that approach as a skill and load it next time instead of reasoning from scratch. It also stores preferences, corrections, and facts about your environment. The practical effect is that it gets faster and more aligned with how you work, and also that mistakes persist unless someone removes them.
A small always-on server, Docker, and an API key for a model provider. The binding constraint is usually the model rather than the machine, because Hermes expects a large context window. It supports Nous Portal, OpenRouter, Anthropic, OpenAI, and other OpenAI-compatible endpoints.
It is riskier in a different way. A stateless agent makes the same class of mistake every time and you notice. An agent with memory can absorb one wrong assumption and apply it consistently for months. The control is not a tighter prompt, it is reading the stored memory and the skills it wrote, on a schedule.
Self-hosting is the default, and Nous also offers a hosted option if you would rather not run the infrastructure. Worth being precise about what self-hosting does and does not give you: the agent, its memory, its skills, and your credentials stay on your machine, but prompts and responses still travel to whichever model provider you point it at, and messages still pass through whichever chat platform you connect. If the requirement is that no content leaves your network at all, that means pairing it with a locally hosted model and avoiding third-party messaging channels.
These pieces are usually decided together. Getting one right rarely helps if the one underneath it is fragile.
Tell us what you are trying to automate and what you have already tried. You will get a straight answer on the smallest responsible next move, including when the answer is to leave it alone.
Request a systems review