Hermes Agent on KnightLi Blog

Deploy Hermes Agent Locally on Windows with WSL + Ollama and Connect Telegram

Sat, 18 Apr 2026 00:48:22 +0800

If you want to run Hermes Agent on Windows with as little friction as possible, a practical path is:

keep Windows as the host system
run Ubuntu inside WSL
use Ollama to serve the local model
let Hermes Agent connect directly to the local Ollama endpoint

This approach keeps the environment relatively clean, lets you run most commands in a Linux-style workflow, and avoids preparing a separate Linux machine.

Overall flow

You can split the setup into 4 steps:

Enable WSL and install Ubuntu
Install Python, Node.js, Git, and other basics inside Ubuntu
Install Ollama and pull a local model
Install Hermes Agent, then connect Telegram

If your goal is simply to get Hermes Agent running first, by the end of step 3 you are already close.

1. Install WSL and Ubuntu

Run this in PowerShell with administrator privileges:

`1`	`wsl --install`

After the installation finishes, restart the PC, then continue with Ubuntu:

`1`	`wsl --install -d Ubuntu`

After that, open Ubuntu in WSL. Most of the remaining commands are run there.

2. Update Ubuntu and install the base environment

Update the system first:

1
2

sudo apt update
sudo apt upgrade -y

Then install Python, extraction tools, Node.js, and Git.

Install Python

`1`	`sudo apt install python3-pip python3-venv -y`

Install zstd

`1`	`sudo apt install -y zstd`

Install Node.js

1
2

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs

Install Git

1
2

sudo apt update
sudo apt install -y git

You can quickly verify the installation with:

1
2
3

node -v
npm -v
git --version

3. Install Ollama and pull Gemma 4

Install Ollama:

`1`	`curl -fsSL https://ollama.com/install.sh \| sh`

If you want a local model for Hermes Agent, starting with Gemma 4 is reasonable.

For example:

`1`	`ollama run gemma4:e4b`

If your machine is weaker, you can also try:

`1`	`ollama run gemma4:e2b`

Larger variants include:

1
2

ollama run gemma4:26b
ollama run gemma4:31b

For most normal Windows + WSL setups, gemma4:e4b is usually the more practical starting point.

4. Install and configure Hermes Agent

Install it with:

`1`	`curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh \| bash`

After installation, point it to the local Ollama endpoint:

`1`	`http://127.0.0.1:11434`

Use the local model name you actually installed, for example:

`1`	`gemma4:e4b`

If the installer asks you to refresh the shell, run:

`1`	`source ~/.bashrc`

Common Hermes Agent commands

These are the commands you will use most often:

Start

hermes

Re-enter setup

`1`	`hermes setup`

Configure the chat gateway

`1`	`hermes setup gateway`

Update

`1`	`hermes update`

Basic Telegram connection steps

If you want Hermes Agent to send and receive messages through Telegram, the core step is still:

`1`	`hermes setup gateway`

Then prepare the two Telegram-side items you need:

create a bot with BotFather
get your User ID with @userinfobot

Once you have those basics, continue filling them into the Hermes Agent gateway setup.

Who this setup fits

This workflow is a good fit if:

Windows is your main desktop system
you do not want to maintain a separate Linux host
you want to get a local Agent running first, then expand to chat platforms
you prefer local models instead of depending on cloud APIs

If you mainly want to experience a local Agent rather than build a full production deployment immediately, this path is already practical enough.

A few things to keep in mind

WSL is still a compatibility layer, so in extreme cases it may not behave exactly like native Linux
whether a large model runs smoothly still depends on your RAM, VRAM, and CPU / GPU
gemma4:e4b is a realistic starting point, but actual experience still depends on the machine
Hermes Agent platform integration is an extension step; getting the local model path working first, then adding Telegram, is usually more stable

Conclusion

If you want to deploy Hermes Agent locally on Windows with as little friction as possible, the smoother order is:

WSL -> Ubuntu -> Ollama -> Gemma 4 -> Hermes Agent -> Telegram

Get the local model running first, then add the gateway integration. That usually gives you a much higher success rate. For most users, this is easier to troubleshoot than piling on every component at the beginning, and it also leaves room for later expansion.

Original reference

This post is rewritten and organized based on:

Xchaoge Blog: 太简单了！Hermes Agent 本地部署（无需API）接入 Telegram + 微信

What Is Hermes Agent: Overview, Strengths, Getting Started, and How It Compares to OpenClaw

Sun, 12 Apr 2026 14:07:58 +0800

If you have been following open-source AI agents lately, Hermes Agent is a project worth paying attention to. Built by Nous Research, its main appeal is not simply that it is “another chat wrapper,” but that it tries to bring long-term memory, reusable skills, context files, MCP extensions, a messaging gateway, and parallel sub-agents into one unified agent runtime.

Based on the official README, Hermes Agent has a very clear goal: it can work like a local CLI assistant in your terminal, or like a cloud-hosted personal assistant that stays available through Telegram, Discord, Slack, WhatsApp, Signal, and other channels. For users who want to combine a coding assistant, an automation assistant, and a personal AI workspace into one system, that positioning is compelling.

01 An overview of Hermes Agent

Hermes Agent is an open-source self-improving AI agent from Nous Research. It supports multiple model providers, including Nous Portal, OpenRouter, OpenAI, and custom OpenAI-compatible endpoints. It can also run across different execution backends such as a local terminal, Docker, SSH, Daytona, and Modal.

What separates Hermes from many “tool-using chatbots” is that it does not focus only on tool calls within a single session. It puts much more emphasis on building persistent capability across sessions. The official docs break this idea down into several parts:

Persistent memory: stores key information about the environment, project, and user preferences through MEMORY.md and USER.md.
Skills system: turns successful workflows into reusable skills that can be loaded on demand.
Context files: automatically reads files such as AGENTS.md, SOUL.md, and .cursorrules to inject project conventions directly into the session.
MCP integration: can connect to any MCP-compatible tool server to extend database, GitHub, filesystem, and scraping capabilities.
Messaging gateway: beyond the CLI, it can also be used through Telegram, Discord, Slack, WhatsApp, Signal, Email, and other entry points.

In one sentence, Hermes Agent feels more like a general-purpose agent operating layer with memory, skills, extensibility, and multi-channel access.

02 Where it stands out

1. It covers both CLI workflows and messaging workflows

Many agent projects lean either toward terminal-based developer assistance or toward chat-platform bots. Hermes tries to combine both. You can run hermes directly in the terminal, or continue with the same assistant through Telegram or Discord after starting the gateway.

The practical benefit is that Hermes is not limited to being useful only when you are sitting in front of your computer. If you deploy it to the cloud or a VPS, it can become a continuously available personal AI assistant.

2. It is designed for long-term use

Hermes does more than chat and call tools. It is also built around long-term accumulation:

Persistent memory with boundaries, instead of endlessly stuffing more context into each conversation.
A skills system that lets you save and reuse successful workflows.
Search across past sessions for retrieval and recall.
Project context files that reduce the need to repeatedly explain the same background.

This matters a lot for people who work repeatedly inside the same repositories, workflows, and team conventions. It means the agent is not just helping once; it can gradually become more familiar with your environment.

3. MCP support gives it strong extensibility

The Hermes documentation explicitly supports MCP and describes both stdio and HTTP integration modes. In practice, that means if an external system already has an MCP server, Hermes can usually connect to it with much lower integration cost.

That is more flexible than writing a custom plugin for every single system. For users who already have tools built around the MCP ecosystem, Hermes should be much easier to extend.

4. It is friendly to OpenClaw users

This part is especially interesting. The Hermes README directly provides hermes claw migrate, and explicitly says it can import configuration, memory, skills, API keys, and messaging platform settings from OpenClaw.

That suggests Hermes is not trying to ignore the existing ecosystem and start from zero. It is clearly positioning some OpenClaw users as a migration audience.

03 How to get started quickly

The officially recommended Hermes Agent installation method is very straightforward:

`1`	`curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh \| bash`

According to the official README, it supports Linux, macOS, WSL2, and Android Termux. One important note is that native Windows is explicitly not supported right now, so Windows users are advised to use WSL2.

After installation, you would usually refresh your shell first:

`1`	`source ~/.bashrc`

Then you can launch it directly:

hermes

If you want to go through a more complete step-by-step initialization flow, the easiest command is:

`1`	`hermes setup`

Based on the official documentation and README, a simple first-time setup path looks like this:

Run hermes setup to finish the base configuration.
Use hermes model to choose a model provider and model.
Use hermes tools to enable the toolsets you want.
Run hermes to enter the interactive CLI.
If you want channels such as Telegram or Discord, continue with hermes gateway.

If you are already an OpenClaw user, it is also worth previewing the migration command:

`1`	`hermes claw migrate --dry-run`

That lets you inspect what can be migrated before doing a real import.

04 How to think about it versus OpenClaw

From the official docs and README, Hermes Agent and OpenClaw are not simply a case of one replacing the other. Their positioning overlaps, but their priorities are clearly different.

What Hermes Agent feels like

Hermes feels more like a product centered on an agent core and workflow system. It emphasizes:

CLI experience
Memory and skill accumulation
Project context files
MCP extensibility
Parallel sub-agents
Switching execution backends across local, container, remote, and serverless environments

If your main goal is to make the agent understand your project better, reuse capabilities over time, and connect more naturally into MCP and developer workflows, Hermes is likely the better fit.

What OpenClaw feels like

OpenClaw feels more like a platform centered on a personal AI assistant plus a messaging gateway. It emphasizes:

Rich messaging channel integration
A continuously running Gateway
A browser-based Control UI
Device pairing, remote access, and status management
Stronger assistant-oriented surfaces such as voice, mobile access, and Canvas

If your main goal is to keep a personal AI assistant reliably available across multiple chat channels and devices, with a control panel to manage it, OpenClaw has a stronger product feel in that direction.

A more practical rule of thumb

You can roughly think of the two like this:

Hermes Agent: more of a “growing general-purpose agent workspace”
OpenClaw: more of a “multi-channel always-on personal AI assistant platform”

That distinction is not absolute, because both projects are still expanding and Hermes also offers a migration path from OpenClaw. But based on the currently public material, Hermes is more prominent on the memory, skills, context, MCP, and developer-workflow side, while OpenClaw looks more mature on the gateway, multi-channel, Control UI, and device-access side.

05 Who should try it

Hermes Agent is especially worth trying first if you fit one of these profiles:

You already rely heavily on AI tools in the terminal and want an agent that better understands your codebase and project rules.
You want to combine AGENTS.md, skills, memory, and MCP into one workflow.
You do not want to be locked into a single model vendor and prefer flexible provider switching.
You already use OpenClaw and want to explore a direction that is more centered on agent workflows.

If you care more about mobile reach, broad IM platform integration, a browser control console, and the feeling of an always-online personal assistant, OpenClaw still has a lot of appeal.

References

Hermes Agent GitHub: https://github.com/NousResearch/hermes-agent
Hermes Agent Docs: https://hermes-agent.nousresearch.com/docs/
Hermes Features Overview: https://hermes-agent.nousresearch.com/docs/user-guide/features/overview
Hermes MCP: https://hermes-agent.nousresearch.com/docs/user-guide/features/mcp/
OpenClaw GitHub: https://github.com/openclaw/openclaw
OpenClaw Getting Started: https://docs.openclaw.ai/start/quickstart
OpenClaw Control UI: https://docs.openclaw.ai/web/control-ui