Hermes AI Agent: Setup, Cost, Local Ollama Models, and Review
If you're looking for an AI agent that can do more than answer questions, Hermes Agent is worth exploring.
Built by Nous Research, Hermes is an open-source AI agent designed to work across your terminal, desktop, and messaging apps. Unlike a typical chatbot, it can use tools, work with files, run commands, maintain memory across sessions, create reusable skills, and delegate work to sub-agents.
The important part is that Hermes itself is free and MIT-licensed. Your actual AI costs depend on the model provider you connect to. You can use cloud models through providers such as Nous Portal, or run supported local models through Ollama without paying an API provider.
This guide explains how Hermes works, how to install it, how Nous Portal differs from local Ollama models, what Hermes costs, and whether it is useful for real-world AI automation.
What Is Hermes AI Agent?
Hermes Agent is an open-source, self-improving AI agent from Nous Research.
The easiest way to understand it is to think of Hermes as the agent layer rather than simply another AI model.
A model provides the intelligence. Hermes provides the environment around that model: tools, memory, skills, sessions, terminal access, messaging integrations, automation, and delegation.
According to the official documentation, Hermes includes persistent memory, a skills system, MCP integration, more than 60 built-in tools/toolsets, and messaging integrations such as Telegram, Discord, Slack, and WhatsApp.
For example, you could ask Hermes to:
Inspect files in a project
Run terminal commands
Search the web
Create or modify files
Perform recurring tasks
Remember information between sessions
Create reusable skills
Delegate separate tasks to sub-agents
Respond through a messaging platform
That makes Hermes considerably different from a normal chat interface.
How Does Hermes Memory Work?
One of Hermes's more interesting features is persistent memory.
A normal chatbot conversation generally starts with a new context when you begin another session. Hermes is designed to retain useful information across sessions.
Its documentation distinguishes between memory and skills.
Memory stores information such as facts about you, projects, or preferences. Skills are reusable procedures that describe how to perform particular types of tasks. Both can persist across sessions.
For example, after repeatedly working on a particular type of task, Hermes can have a reusable skill describing the process instead of requiring you to explain the entire workflow every time.
This is one reason Hermes is better thought of as an agent framework than simply a chatbot.
How to Install Hermes Agent
Hermes supports Windows, macOS, Linux, WSL2, and other environments documented by Nous Research.
For Windows, the official documentation provides a PowerShell installation method:
iex (irm https://hermes-agent.nousresearch.com/install.ps1)
For Linux, macOS, WSL2, and supported terminal environments, the documented installation command is:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
After installation, reload your shell if necessary and start Hermes:
hermes
The official documentation also provides a desktop installer for Windows and macOS.
If you're new to Hermes, don't immediately configure every available integration. First make sure a basic conversation works.
The recommended workflow is:
Install Hermes.
Choose a model provider.
Start a normal chat.
Verify that the model responds correctly.
Add messaging, automation, skills, MCP, or other tools afterward.
This approach makes troubleshooting much easier.
Step 1: Choose Your Model Provider
After installation, run:
hermes model
This opens Hermes's model/provider configuration flow.
You have several choices, including cloud providers and local model endpoints.
There are two particularly important options for beginners:
Nous Portal and local Ollama models.
They can both power Hermes, but they solve different problems.
Nous Portal vs Local Ollama
The difference is simple:
Nous Portal = cloud-based convenience
Ollama = local/self-hosted inference
Nous Portal
Nous Portal is Nous Research's unified subscription gateway for Hermes.
The current Hermes documentation says Portal provides access to 300+ models through one subscription and includes the Tool Gateway for services such as web search, image generation, text-to-speech, and cloud browser functionality.
The fastest setup is:
hermes setup --portal
The command starts the Portal OAuth flow, lets you select a model, configures Hermes to use Nous as the provider, and enables the Tool Gateway.
Current Portal plans shown by Nous Research include:
Free: $0, free models only
Plus: $20/month, with $22 in monthly credits
Super: $100/month, with $110 in monthly credits
Ultra: $200/month, with $220 in monthly credits
Paid plans also provide access to the broader model catalog and hosted tool usage.
So you don't have to buy a Portal subscription just to use Hermes.
Local Ollama Models
Ollama takes a different approach.
Instead of sending prompts to a cloud provider, you run a model on your own computer.
Hermes can connect to Ollama through its OpenAI-compatible local endpoint:
http://localhost:11434/v1
The official Hermes documentation explains that local models can run without an API key or subscription, and your model inference stays on your computer after the model has been downloaded.
A basic Ollama workflow looks like this:
ollama pull gemma4:31b
Then configure Hermes with:
Base URL: http://localhost:11434/v1 API Key: leave empty Model: your downloaded Ollama model
You can configure this through:
hermes setup
or select the custom endpoint through:
hermes model
The exact model you should use depends heavily on your hardware.
A small local model may run on a normal computer but provide weaker agentic performance. Larger models require considerably more RAM or GPU memory. Hermes's own Ollama guide lists 8 GB RAM as a starting point for smaller models and recommends 32 GB or more for larger models.
Which approach should you use?
Choose Nous Portal if you want:
Easier setup
Access to many cloud models
Hosted tools
Less hardware dependency
Faster access to powerful models
Choose Ollama/local models if you want:
Local inference
No per-token API bill
More control over your data
Offline/self-hosted operation after downloading models
The ability to experiment with open-weight models
There is also nothing stopping you from configuring multiple providers and switching between them later.
How to Run Hermes With Ollama
First install Ollama and verify that it works:
ollama --version
Then download a compatible model:
ollama pull gemma4:31b
Check that Ollama is exposing its local API:
curl http://localhost:11434/api/tags
Next run:
hermes setup
Select the custom endpoint option and enter:
http://localhost:11434/v1
Leave the API key empty if Hermes accepts the blank value for your setup.
Then select the model you downloaded.
One important detail is tool calling.
Hermes is an agent, so the model needs to be capable of working with tools if you want the full agent experience. A model that can only generate conversational text won't provide the same functionality as a model capable of agentic tool use.
Ollama also documents a simpler integration:
ollama launch hermes
This can automate much of the Hermes/Ollama configuration and let you choose between available models.
What Can Hermes Actually Do?
Hermes becomes more interesting once you start using its tools.
1. Run Background Automations
Hermes can be used for recurring workflows.
For example, you could build an automated routine that:
Checks information periodically
Creates a report
Processes files
Performs scheduled tasks
Sends results through a connected messaging service
Hermes includes cron/automation capabilities as part of its broader agent tooling.
2. Use Web and Other Tools
Depending on your configuration and provider, Hermes can work with web search, browser tools, image generation, text-to-speech, and other services.
This is where the distinction between a model and an agent becomes important.
A model produces an answer.
An agent can decide to use a tool, inspect its result, and continue working.
3. Delegate Tasks to Sub-Agents
Hermes can delegate work to sub-agents.
Instead of making one model perform every part of a large task sequentially, an agent can split certain jobs into separate pieces.
For example:
Main Agent ├── Research task ├── Code investigation └── Documentation task
The usefulness of this depends on the model, task, hardware, and configuration, but delegation is an important part of Hermes's agent architecture.
4. Connect Messaging Apps
Hermes isn't limited to a terminal window.
Its messaging gateway supports platforms including Telegram, Discord, Slack, and WhatsApp.
That means you can potentially interact with an agent running elsewhere without opening your development environment every time.
For example, you could have Hermes running on a desktop or server and send it a task through Telegram.
Is Hermes AI Agent Free?
Yes, but there is an important distinction.
The Hermes software itself is free and open source under the MIT license.
That does not mean every model or external service is free.
If you connect Hermes to a paid API, you pay that provider's usage charges.
If you use Nous Portal, your access depends on the Portal plan and its included credits.
If you use a local Ollama model, there is no model API charge, although you still have the hardware, electricity, storage, and setup costs of running the model yourself.
So the realistic cost model is:
Hermes software: Free
Local Ollama inference: No API charge
Cloud APIs: Provider-dependent
Nous Portal: Free and paid plans available
Hermes Agent Review: Is It Actually Useful?
Hermes is interesting because it tries to combine several AI-agent capabilities into one open-source system.
Its strongest concept is the combination of memory + skills + tools + persistent sessions + messaging + automation.
For someone who wants a personal AI agent that continues working across different sessions and interfaces, those features are more significant than simply having another chatbot.
The open-source nature is also important. You aren't locked into a single model provider. Hermes can work with different providers and local model infrastructure, allowing you to change the underlying model without replacing the entire agent environment.
However, Hermes isn't completely frictionless.
Agent systems have more moving parts than ordinary chat applications. Model configuration, tool permissions, API providers, messaging gateways, local hardware, MCP servers, and authentication can all introduce additional troubleshooting.
Local models also have an obvious hardware trade-off. A powerful cloud model may respond much faster than a large model running on a CPU. Hermes's own local-model documentation notes that CPU-only inference can be significantly slower, particularly with larger models.
For that reason, Hermes is best understood as an agent platform, not a magic replacement for every AI application.
Hermes Agent vs Pi
Hermes and Pi can be used for different styles of workflows.
Hermes focuses heavily on persistent memory, skills, tools, automation, messaging integrations, and long-running agent workflows.
Pi is designed around a more minimal terminal-oriented experience.
The practical difference is therefore less about which application is universally better and more about the workflow you're trying to build.
If your priority is a persistent agent with multiple integrations and automation capabilities, Hermes's architecture is built around those features.
If your priority is a minimal coding-oriented terminal environment, a lighter agent may be more appropriate.
Is Hermes the Same as "Hermes OS"?
No.
"Hermes OS" can be used informally to describe the broader always-on-agent concept, but the official project is Hermes Agent.
The software itself is the open-source Hermes Agent project from Nous Research.
Does Hermes Work on Mobile?
Hermes does not require a traditional mobile app to be useful.
The project supports messaging integrations, allowing you to communicate with an agent through services such as Telegram and WhatsApp. The documentation also lists Android/Termux among supported installation environments.
This means the experience can be mobile-friendly even when the main agent is running on another computer or server.
Final Verdict: Who Should Try Hermes?
Hermes Agent is worth investigating if you want more than a conventional AI chatbot.
Its main attraction is the combination of:
Persistent memory
Reusable skills
Terminal and file tools
Web and external integrations
Sub-agent delegation
Automation
Multiple model providers
Local model support
Messaging integrations
Open-source licensing
The biggest decision is not whether Hermes itself costs money. It doesn't.
The real question is which model backend you want to use.
For convenience and access to many cloud models, Nous Portal provides a straightforward route.
For local, self-hosted inference, Ollama gives you a different architecture where the model runs on your own hardware.
You can also keep multiple providers configured and switch between them as your requirements change.
That flexibility is arguably one of Hermes's most useful features: you can change the model without having to abandon the entire agent environment.
For developers, AI power users, and people experimenting with autonomous workflows, Hermes is therefore an interesting open-source project to test—especially if persistent memory, automation, and tool use matter more to you than simply having another chat interface.