Hermes Agent: Is the AI ​​agent that learns on its own really ready for your business?

An AI agent capable of answering questions is no longer anything exceptional.

An agent capable of using a browser, executing code, manipulating files or triggering tools is already becoming more interesting.

But Hermes Agent goes further.

It can retain memory across sessions, search through previous conversations, create its own skills and reuse methods that have worked before.

In other words, it does not simply execute a task.

It gradually learns how you work.

That is precisely what makes Hermes Agent interesting.

And potentially risky.

Because when an agent has persistent memory, terminal access, scheduled tasks and access to company tools, the issue is no longer limited to the quality of its answers.

The real question becomes:

How far can an AI agent be allowed to learn and act without losing control?

What Is Hermes Agent?

Hermes Agent is an open-source AI agent developed by Nous Research.

It should not be confused with Hermes 3, a language model also developed by Nous Research. Hermes Agent is a complete software layer capable of using different models, calling tools and maintaining a persistent state over time.

The agent can be installed on a computer, private server, virtual machine or cloud infrastructure. It can also be used through a desktop application, a terminal or various messaging platforms.

Hermes Agent can notably be connected to:

Slack;

Telegram;

Discord;

WhatsApp;

Signal;

Microsoft Teams;

an email inbox;

a command-line interface.

The idea is to access the same agent, memory and skills across multiple interfaces.

However, Hermes’ main value does not come from the number of available channels.

It comes from its ability to retain and reuse what it learns.

An AI Agent That Turns Experience Into Skills

Most AI assistants start almost from scratch with every new conversation.

They may retain a conversation history or receive custom instructions, but they do not necessarily transform previous experiences into structured procedures.

Hermes Agent introduces a different approach through its skill system.

A skill is a document containing the instructions required to complete a specific task. For example, it may explain how to:

deploy an application;

open a pull request;

analyse data;

generate a report;

query a business tool;

execute an internal procedure.

These skills are only loaded when they are useful, preventing the model’s context from becoming unnecessarily overloaded. They may come from the built-in library, be created manually or be generated by the agent itself.

When Hermes completes a complex task, encounters several errors before finding a solution or receives a correction from the user, it can save the resulting method as a new skill.

The next time, it no longer needs to rediscover the entire procedure.

It can build on what it has already learned.

This is what Nous Research describes as an integrated learning loop.

Hermes does not necessarily retrain the model it uses. Instead, it improves its behaviour by enriching its memory, instructions and library of procedures.

The distinction is important.

The agent does not spontaneously become more intelligent.

It gradually becomes better equipped to operate within a specific environment.

Hermes Agent Is Not Tied to a Single Model

Hermes Agent can use models from several providers.

It can notably be connected to cloud APIs or self-hosted models through solutions such as Ollama or vLLM. Its architecture also distinguishes between the primary model, used for reasoning and executing tasks, and auxiliary models responsible for more specific functions such as context compression, vision, skill retrieval or MCP tool routing.

In theory, this separation makes it possible to adapt each model to the complexity of the task.

For example, a company could use:

an advanced model for decision-making;

a less expensive model for summarising documents;

a local model for certain sensitive data;

a specialised model for analysing images;

another model for finding the right tool to call.

Hermes is therefore closer to an agentic orchestration system than to a simple chatbot.

What Tools Can Hermes Agent Use?

Hermes includes numerous built-in tools for interacting with its environment.

Depending on the chosen configuration, it can notably:

browse the Web;

read and modify files;

run commands in a terminal;

execute code;

analyse images or videos;

manage memory;

schedule tasks;

delegate work to sub-agents;

search through previous sessions;

create or modify its own skills.

The documentation also mentions an integration with MCP, the Model Context Protocol. Hermes can therefore dynamically load tools exposed by external MCP servers.

This means that it can theoretically be connected to a CRM, database, GitHub, ERP system, ticketing tool or internal API.

MCP makes it easier to connect an agent to company systems, but it does not automatically secure the actions performed. The exposed tools, granted permissions and validation rules must still be configured correctly. We explored this subject in detail in our guide to the Model Context Protocol and connecting AI systems to business tools.

Practical Example: A Hermes Agent Within a Team

Imagine a product team that installs Hermes on a private server and connects it to Slack, GitHub and its project management tool.

A team member could ask it:

“Analyse the bugs opened this week, group similar issues together and prepare the priorities for the next sprint.”

To complete this task, the agent could:

find the relevant tickets;

read the discussions associated with each issue;

review the relevant parts of the code;

identify the most common errors;

prepare a summary;

publish a message in Slack;

save the procedure as a skill.

The following week, the same work could be launched automatically through a scheduled task.

On paper, the time savings are obvious.

However, this scenario assumes that the agent can read tickets, access the code, run commands and publish a result visible to several people.

Each new capability therefore also increases the potential attack surface.

What Makes Hermes Different From an n8n Automation?

A traditional automation generally follows a predefined scenario:

When a specific event occurs, execute a predetermined sequence of actions.

An agent such as Hermes works differently.

It is given an objective, a set of tools and certain constraints. It then chooses the actions it considers necessary to achieve that objective.

An n8n automation may be more predictable and easier to audit.

Hermes may be more flexible when a task requires it to:

explore several sources;

adapt its plan;

interpret unstructured information;

handle different situations;

choose between several tools.

The two approaches are not necessarily opposed.

A robust architecture can use n8n to orchestrate critical steps and Hermes only for the parts that require reasoning.

We also explore this distinction in our article about choosing between an AI agent and traditional automation.

Why Persistent Memory Changes the Level of Risk

Memory is often presented as one of the most useful features of AI agents.

It prevents users from having to repeatedly explain the project context, their preferences, the organisation’s structure or important procedures.

However, persistent memory may also retain:

information that has become outdated;

a misinterpretation;

sensitive data;

a correction that only applied to a specific case;

a malicious instruction;

behaviour that no one has genuinely validated.

An error in a traditional conversation usually disappears when the session ends.

An error stored in an agent’s memory can influence several weeks of work.

The problem becomes even more significant when the agent turns an experience into a skill.

An incorrect procedure may then be repeated automatically and with greater confidence because it is considered an already acquired skill.

Memory and skills must therefore be treated as genuine components of the information system.

They must be able to be:

reviewed;

corrected;

versioned;

deleted;

restored;

attributed to a source;

audited over time.

An Agent That Can Modify Its Own Procedures

Hermes’ documentation states that local skills are the primary source used by the agent and that it can create, update or delete them.

This capability is powerful.

It enables the agent to gradually improve a procedure without requiring a developer to modify its code every time.

However, it also raises an essential question:

Can a company allow an agent to independently modify the instructions that determine its future behaviour?

In a personal or experimental environment, the risk may be acceptable.

In a business environment, any significant modification should ideally go through:

a proposed change;

a comparison with the previous version;

human approval;

a change history;

the ability to roll back.

Learning must not become a silent modification of the system.

Scheduled Tasks Make the Agent Truly Autonomous

Hermes makes it possible to schedule reports, backups, summaries or other recurring tasks using natural language. These automations can run without a user being present at the time of execution.

This is the point at which an assistant becomes genuinely autonomous.

An agent launched manually remains under direct supervision.

An agent capable of working every night, interacting with external services and publishing results requires another level of control.

It is particularly important to define:

what happens when an API stops responding;

the maximum number of actions allowed;

the maximum acceptable expenditure;

the hours during which the agent is allowed to act;

the data it can access;

the people who should be notified if something fails;

the actions that must always require approval.

Without these limits, a small error may be repeated dozens of times before it is detected.

The Security Mechanisms Already Provided by Hermes

Hermes Agent does not ignore these risks.

Its documentation describes a defence-in-depth security approach organised around several layers:

authorising the users allowed to communicate with the agent;

human approval for dangerous commands;

restrictions on file-writing operations;

container isolation;

filtering credentials transmitted to MCP servers;

detecting prompt injections in context files;

separating different sessions;

validating parameters passed to the terminal.

The agent can notably be run inside a Docker container or on a remote server to limit its direct access to the user’s machine. The documentation recommends this isolation when the agent needs to use a terminal.

Hermes also makes it possible to create several independent profiles.

Each profile has its own configuration, API keys, memory, sessions, skills and scheduled tasks. A company could therefore separate a research agent, a development agent and an agent connected to sales tools.

These mechanisms provide a solid foundation.

However, they do not replace the architecture work required for each individual company.

A tool may require approval for dangerous commands without knowing that a specific change in your CRM is commercially critical.

Technical security does not automatically understand business rules.

Is Hermes Agent Ready for Enterprise Use?

The answer depends less on the tool itself than on the level of autonomy it is given.

Yes, for Controlled Experiments

Hermes may already be relevant for:

conducting research;

preparing summaries;

analysing non-sensitive documents;

assisting a development team;

generating drafts;

producing internal reports;

exploring data in an isolated environment.

In these situations, the agent can provide value while maintaining human approval before any important action is performed.

With Caution, for Internal Tools

Hermes can be connected to business tools, provided that strict limits are placed on:

the data it can access;

the actions it can perform;

the authorised users;

the environments concerned;

the budgets;

the execution times;

the available modification capabilities.

It is better to begin with a read-only agent operating within a limited scope before allowing it to modify data.

Not Without a Dedicated Architecture for Critical Processes

It would be risky to allow a general-purpose agent to independently manage:

payments;

data deletion;

permission changes;

HR decisions;

production deployments;

external communications;

accounting changes;

irreversible operations.

For these subjects, the agent can analyse, recommend and prepare.

The final decision must remain controlled by a deterministic rule or human approval.

A Technology That Is Still Evolving Rapidly

Hermes Agent is currently evolving at a particularly fast pace.

Version 0.19.0, released on July 20, 2026, notably arrived after several thousand commits, more than a thousand merged pull requests and several major developments involving performance, sub-agents, memory and deployment.

This pace demonstrates an active community and an ambitious project.

It also means that the tool is not yet a fixed infrastructure.

For a company, this means it is necessary to:

pin deployed versions;

test updates;

monitor security changes;

maintain a rollback procedure;

avoid unsupervised automatic updates;

document expected behaviours.

Open source provides visibility into the code.

It does not automatically guarantee operational stability.

How to Test Hermes Agent Without Taking Unnecessary Risks

An initial experiment can follow a gradual approach.

1. Choose a Single Use Case

Avoid starting with the objective of “creating an agent for the entire company.”

Choose a task that is specific, frequent and easy to verify.

For example:

preparing a weekly monitoring report;

summarising tickets;

classifying documents;

producing meeting minutes;

analysing logs;

searching for information in a knowledge base.

2. Use a Dedicated Profile

Do not immediately mix professional, personal and technical uses.

Create an independent profile with its own memory, tools and credentials.

3. Start in Read-Only Mode

The agent can initially access data and produce a recommendation.

It does not necessarily need to modify the CRM, send an email or deploy code in the first version.

4. Isolate Its Execution Environment

The terminal should run inside a container or on a dedicated machine.

By default, the agent should not have full access to an employee’s workstation or the internal network.

5. Limit the Available Tools

A monitoring agent does not need access to the billing system.

A development agent does not need to access HR data.

Each agent should only have the minimum access required.

6. Control Memory and Skills

You need to know what information has been stored, why it was stored and how it can be deleted.

New skills created by the agent must be reviewable before they are used for a critical task.

7. Maintain Human Approval

Any external, financial, destructive or difficult-to-reverse action must remain subject to approval.

8. Measure the Results

The evaluation should not be limited to a few successful demonstrations.

You should measure:

the percentage of tasks completed correctly;

errors;

the amount of time genuinely saved;

model costs;

the number of human interventions;

unexpected behaviours;

how easily errors can be corrected.

Does Hermes Represent the Future of AI Assistants?

Probably.

The most useful AI assistants will not simply be able to answer questions.

They will need to understand the company’s context, work with its tools, remember its procedures and improve gradually.

Hermes Agent demonstrates what this next generation could look like:

persistent;

connected;

capable of using multiple tools;

self-hostable;

capable of creating its own procedures;

accessible through multiple interfaces.

However, this evolution also changes the nature of the project.

Installing Hermes is not simply a matter of adding a chatbot to Slack.

It means introducing a new software actor capable of observing, remembering, deciding and acting.

The more capable this actor becomes, the more carefully its permissions, memory and behaviour must be controlled.

Conclusion

Hermes Agent is one of the most interesting open-source projects in the AI agent space today.

Its persistent memory, skill system and ability to use different tools enable it to go far beyond a traditional conversational assistant.

However, its greatest strength is also its greatest risk.

An agent that learns must be able to unlearn.

An agent that acts must be able to be restricted.

An agent that modifies its own procedures must be auditable.

And an autonomous agent must always operate within an architecture designed to absorb its mistakes.

The right question is therefore not:

“Is Hermes Agent intelligent enough to work in my company?”

The real question is:

“Is my company ready to govern an agent capable of learning and acting over time?”

At Scroll, we help companies define, connect and industrialise their AI assistants.

The objective is not to make AI autonomous at all costs.

The objective is to give it the right level of autonomy, within the right scope and with the right controls.