Hermes Agent: NousResearch's Self-Improving AI

TL;DR

Hermes Agent is NousResearch’s open-source AI agent that lives on your server and connects to 12 messaging platforms. Key highlights:

13,500+ GitHub stars and growing fast
12 messaging platform integrations: Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Home Assistant, Email, SMS, and more
Self-improving skills: Agent creates and loads its own skills as markdown files when solving hard problems
6 execution backends: Local subprocess, Docker, Singularity, Modal (serverless), SSH, Daytona
Model-agnostic: Works with Claude, GPT, Gemini, DeepSeek, Kimi, MiniMax, or any of 200+ models via OpenRouter
Persistent memory: MEMORY.md + USER.md with file locking, injection scanning, and Honcho integration
MIT licensed: Fully open-source, runs on a $5 VPS or GPU cluster

Install with: curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

What Is Hermes Agent?

Most AI agents help you write code. Hermes Agent helps you manage your digital life across every platform you use.

Built by NousResearch — the team behind the Hermes series of fine-tuned models — Hermes Agent is an autonomous AI that runs headless on your server and connects to the messaging platforms where you actually work. It’s not a coding copilot. It’s not a chatbot wrapper. It’s an always-on agent that monitors your Discord servers, responds on Telegram, coordinates in Slack, and handles WhatsApp messages — all while maintaining persistent memory and self-improving skills.

The tagline says it all: “The agent that grows with you.”

Think of Hermes Agent not as something you interact with in an IDE, but as an autonomous server process that can:

Manage your Discord community with context-aware responses, media handling, and threading
Run scheduled automations — daily reports, nightly backups, weekly audits — unattended
Create and refine its own skills when solving novel problems, then reuse them automatically
Execute tasks across 6 different sandbox backends from local processes to serverless cloud
Aggregate responses from 4 frontier models simultaneously using Mixture of Agents
Delegate complex work to isolated subagents with their own conversations and terminals

The project is built on NousResearch’s fine-tuned Hermes-4-405B model (a Llama 3.1 405B fine-tune trained on approximately 5 million samples and 60 billion tokens), but it’s fully model-agnostic. Point it at Claude, GPT, Gemini, DeepSeek, or any OpenAI-compatible API through OpenRouter and it works.

Hermes Agent has accumulated over 13,500 GitHub stars and the trajectory is steep. Several factors explain the momentum:

The Multi-Platform Gap

The AI agent space has been obsessed with coding assistance throughout 2025-2026. Cursor, Claude Code, GitHub Copilot, Windsurf — these are all excellent tools for developers working in IDEs and terminals. But there’s been a conspicuous gap: what about everyone who lives in Discord, Slack, Telegram, and WhatsApp?

Community managers, team coordinators, Discord server operators, and anyone managing conversations across multiple platforms have been underserved. Hermes Agent fills that gap with the most comprehensive multi-platform gateway available in the open-source ecosystem.

NousResearch’s Reputation

NousResearch has built deep credibility in the open-source AI community through their Hermes model series. The Hermes fine-tunes have consistently ranked among the best open-weight models for instruction following and agentic tasks. When NousResearch released an agent framework built around their model expertise, the community paid attention.

Self-Improving Systems

The concept of an agent that creates its own skills — not through gradient updates or fine-tuning, but through structured markdown files with YAML frontmatter — resonated with developers who wanted AI systems that get better without retraining. Whether you consider this “real” self-improvement or sophisticated prompt management, the practical result is an agent that handles similar problems better over time.

Key Features

Multi-Platform Gateway

This is THE killer feature — and it’s not close.

Hermes Agent ships with 12 messaging platform adapters:

Telegram — Full bot API integration with media handling
Discord — The most complete adapter at 2,085 lines, with threading, typing indicators, and rich embeds
Slack — Workspace integration with channel-aware responses
WhatsApp — Via WhatsApp Business API
Signal — End-to-end encrypted messaging support
Matrix — Decentralized messaging protocol support
Home Assistant — Smart home integration for voice and automation
Email — IMAP/SMTP with attachment handling
SMS — Via Twilio or compatible providers
IRC — Classic protocol support
Webhook — Generic HTTP endpoint for custom integrations
REST API — Direct programmatic access

Each adapter isn’t a thin wrapper. They handle real media (images, files, audio), maintain threading context, show typing indicators, and respect platform-specific rate limits and formatting. The Discord adapter alone is over 2,000 lines of carefully engineered integration code.

No other open-source agent offers this breadth of platform support with this depth of implementation.

Self-Improving Skills System

Hermes Agent’s skills are Markdown files with YAML frontmatter that get injected into the agent’s context. What makes this interesting is that the agent creates new skills automatically when solving hard problems.

Here’s how it works:

Agent encounters a novel, complex problem
After solving it, the agent generates a skill file describing the approach
On future similar tasks, the skill is automatically loaded into context
Skills can be shared, installed, and managed like packages

---
name: discord-moderation
description: Moderate Discord channels with context-aware content filtering
triggers:
  - discord message
  - moderation request
  - content filter
version: 1.2.0
---

## Steps

1. Analyze message content and sender context
2. Check against community guidelines loaded from server config
3. Apply graduated response: warn, timeout, or escalate to human mod
4. Log action to moderation audit channel
5. Update user risk score in memory

The project ships with 40+ bundled skills covering MLOps, GitHub workflows, research tasks, and more. Skills are compatible with the agentskills.io open standard, and you can install community skills from ClawHub and LobeHub.

Persistent Memory

Hermes Agent maintains two primary memory files:

MEMORY.md — Agent’s accumulated knowledge, context, and learned patterns
USER.md — User-specific preferences, history, and modeling

The memory system is more thoughtful than a simple append-to-file approach:

Atomic writes via temporary files prevent corruption
File locking prevents race conditions from concurrent access
Injection scanning guards against prompt injection attacks in stored memories
Character budgets keep memory files from growing unboundedly
Frozen snapshots provide cache stability for consistent context injection

For more sophisticated user modeling, Hermes Agent integrates with Honcho for dialectic user modeling — building a dynamic understanding of users through conversational patterns rather than static profiles.

Terminal Backends

Hermes Agent offers 6 execution backends for running commands and code:

Local Subprocess — Direct execution on the host. Fast, minimal overhead.
Docker — Container isolation with persistent shells. The recommended default.
Singularity — HPC-friendly containerization for research computing environments.
Modal — Serverless cloud execution. Spin up GPU instances on demand without managing infrastructure.
SSH — Remote execution on any accessible machine.
Daytona — Cloud development environment integration.

# Configure execution backend
hermes config set terminal.backend docker

# Or use Modal for serverless GPU access
hermes config set terminal.backend modal
hermes config set terminal.modal.gpu A100

Each backend maintains persistent shell state, isolates environment variables, and includes a dangerous command approval system — the agent won’t run rm -rf / without explicit human approval.

Scheduled Automations

Hermes Agent includes a built-in cron scheduler that accepts natural language:

# Schedule via natural language
hermes schedule "Every morning at 8am, summarize overnight Discord activity and post to #daily-digest"
hermes schedule "Every Friday at 5pm, generate a weekly metrics report and email it to the team"
hermes schedule "Every 6 hours, check GitHub issues labeled 'urgent' and notify me on Telegram"

These automations run unattended through the gateway. Combined with the multi-platform adapters, you get an agent that monitors, reports, and acts on a schedule across all your communication channels.

Subagent Delegation

For complex multi-step tasks, Hermes Agent can spawn isolated subagents:

Each subagent gets its own conversation context, terminal session, and Python RPC scripts
The parent agent delegates work without polluting its own context window
Results are aggregated back with zero context cost to the parent
Enables pipeline-style workflows where each stage is handled by a focused subagent

Mixture of Agents

Hermes Agent implements the published Mixture of Agents (MoA) paper in approximately 550 lines of code:

Send the same prompt to 4 frontier models in parallel (Claude, Gemini, GPT, DeepSeek)
Collect all 4 responses
A 5th model aggregates the responses into a synthesized answer

This gives you consensus-quality responses for critical decisions — at the cost of 4x the API calls. It’s optional and configurable, but powerful when you need high-confidence answers.

40+ Built-In Tools

The tool ecosystem covers:

Web search and browser automation (Playwright-based)
Vision — Image analysis and understanding
Image generation — Via DALL-E, Stable Diffusion, or compatible APIs
Text-to-speech — Audio generation from text
Code execution — Across all 6 terminal backends
Multi-model reasoning — The MoA system described above
File operations — Read, write, search across the filesystem

Getting Started

Installation

# One-line install
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# Interactive setup wizard
hermes setup

# Select your model
hermes model

# Start chatting
hermes

The hermes setup wizard walks you through API key configuration, model selection, and basic preferences. It takes about two minutes.

Gateway Setup

To enable the multi-platform messaging gateway:

# Configure gateway adapters
hermes gateway setup

# Start the gateway
hermes gateway

# Install as a systemd service (runs on boot)
hermes gateway install

The gateway setup wizard lets you enable and configure each platform adapter individually. You’ll need API tokens for each platform — a Discord bot token, Telegram bot token, Slack app credentials, etc.

Configuration

Hermes Agent’s configuration is straightforward:

# ~/.hermes/config.yaml
model:
  provider: openrouter
  name: nousresearch/hermes-4-405b
  fallback: anthropic/claude-sonnet-4-20250514

gateway:
  discord:
    enabled: true
    token: ${DISCORD_BOT_TOKEN}
  telegram:
    enabled: true
    token: ${TELEGRAM_BOT_TOKEN}
  slack:
    enabled: true
    token: ${SLACK_BOT_TOKEN}

terminal:
  backend: docker
  timeout: 300

memory:
  enabled: true
  max_chars: 50000
  honcho: false

schedule:
  enabled: true
  timezone: America/New_York

First Run

# Start the agent in terminal mode
hermes

# Or start the full gateway (all platforms)
hermes gateway

# Check status
hermes status

Once the gateway is running, your agent is live on every configured platform. Send it a message on Discord and it responds. Message it on Telegram and it responds there too — with shared memory and context across all platforms.

Real-World Use Cases

Discord Community Management

The strongest use case and where Hermes Agent genuinely shines:

Setup: Enable Discord adapter, configure for your server
Agent will:
1. Monitor all channels it has access to
2. Respond to mentions and DMs with context-aware replies
3. Handle moderation tasks based on configured skills
4. Post scheduled updates to designated channels
5. Process images, files, and media shared in conversations
6. Maintain per-user memory across all interactions

Multi-Platform Team Coordination

For teams spread across Slack, Discord, and Telegram:

Setup: Enable Slack, Discord, and Telegram adapters
Agent will:
1. Monitor all three platforms simultaneously
2. Cross-post important updates when instructed
3. Maintain unified memory of conversations across platforms
4. Run scheduled reports delivered to the appropriate channel
5. Handle task delegation and follow-up across platforms

Automated Monitoring & Reporting

Using scheduled automations with the gateway:

Setup: Configure schedules with platform delivery targets
Agent will:
1. Run research tasks on a cron schedule
2. Check GitHub repos, APIs, or websites for changes
3. Generate formatted reports
4. Deliver results to Slack channels, Telegram chats, or email
5. Escalate urgent findings via SMS or direct message

Research Pipeline with Mixture of Agents

For high-stakes decisions requiring consensus:

Setup: Configure MoA with 4 frontier models
Agent will:
1. Send your query to Claude, GPT, Gemini, and DeepSeek simultaneously
2. Collect and compare all 4 responses
3. Aggregate into a synthesized answer using a 5th model
4. Store the consensus and dissenting views in memory
5. Deliver the result to your preferred platform

Community Reactions

DEV.to Reviews

An honest technical review on DEV.to captured the community sentiment well:

“Hermes Agent is real software with real engineering effort: 40 tool modules, 12 platform adapters, active development. The multi-platform gateway is genuinely impressive and has no equivalent in the ecosystem.”

The review praised the gateway architecture and the depth of each platform adapter while noting that the breadth of features means some components are more polished than others.

Reddit (r/LocalLLaMA)

The r/LocalLLaMA community — always quick to evaluate new open-source AI tools — had active discussions about Hermes Agent. Comparisons to OpenClaw were frequent, with users asking “how does this differ from a well-configured OpenClaw setup?”

The consensus: Hermes Agent’s multi-platform gateway is its differentiator. OpenClaw has the larger ecosystem, but if you need an agent that lives on Discord, Telegram, and Slack simultaneously, Hermes Agent is purpose-built for that.

LinkedIn & Industry

Shubham Saboo and other AI practitioners highlighted Hermes Agent’s traction on LinkedIn, particularly the speed of star accumulation and the quality of the gateway implementation.

Criticism

The community raised valid concerns:

Memory is structured note-taking, not learning — MEMORY.md is fundamentally markdown on disk. There’s no embeddings, no retrieval-augmented generation, no actual machine learning. The agent doesn’t “learn” in any ML sense — it writes notes and reads them back.
Skills are structured prompt injection with a CRUD layer — While the skills system is well-engineered, some developers argue it’s sophisticated prompt management rather than genuine self-improvement.
Wrapper-layer concerns — Web tools and browser automation wrap existing libraries rather than implementing from scratch. This is pragmatic engineering, but it means you inherit those dependencies’ limitations.
Default model isn’t their own — Despite being built by NousResearch, the default configuration ships pointed at Claude Opus via OpenRouter, not Hermes-4-405B. This raises questions about whether even NousResearch considers their own model the best option for agentic tasks.

Honest Limitations

Python Dependency

Hermes Agent is written in Python, which means:

Heavier runtime than Go or Rust alternatives
Dependency management via pip/poetry can be fragile
Memory usage is higher than compiled alternatives
Cold start times are noticeable on resource-constrained machines

For a $5 VPS use case, this matters. Python’s overhead eats into your limited resources more than a compiled binary would.

No Native Windows Support

Windows users need WSL2. This isn’t unusual for server-side agent tools, but it’s worth noting if you’re evaluating deployment options. macOS and Linux are first-class citizens.

Setup Requires Technical Comfort

While the install script and setup wizard simplify things, you still need:

Comfort with the terminal and configuration files
API keys for your chosen model provider
Platform-specific bot tokens for each messaging adapter
Understanding of systemd if you want the gateway to run as a service

If you can’t create a Discord bot and get its token, you’ll struggle with the gateway setup.

Smaller Community

At 13,500 stars, Hermes Agent has a growing but smaller community compared to OpenClaw’s 160,000+ stars. This means:

Fewer community-created skills and integrations
Smaller pool of Stack Overflow answers and troubleshooting guides
Less third-party tooling built around it
Faster-moving codebase with potential for breaking changes

Memory Is Markdown on Disk

Let’s be direct: the persistent memory system is files on disk. MEMORY.md and USER.md are well-engineered (atomic writes, file locking, injection scanning), but they’re fundamentally text files. There’s no vector store, no semantic search, no embedding-based retrieval. For simple use cases this works fine. For agents managing thousands of interactions across 12 platforms, flat files will hit scaling limits.

Portal Onboarding

NousResearch’s Portal — their paid inference service — has onboarding friction. If you’re using Portal for model access, expect some setup hurdles. OpenRouter is the smoother path for most users.

Hermes Agent vs Alternatives

Comparison Table

Feature	Hermes Agent	OpenClaw	DeerFlow 2.0
Primary strength	Multi-platform gateway	Ecosystem & extensions	Autonomous execution
GitHub stars	13.5K	160K	39K
Messaging platforms	12	10+	3 (Telegram, Slack, Feishu)
Model support	Any via OpenRouter	Any via config	OpenAI, Claude, DeepSeek, Doubao
Execution backends	6 (local, Docker, SSH, Modal, Daytona, Singularity)	Local, Docker, SSH	Docker, Kubernetes
Skills system	Auto-generated	SKILL.md format	Markdown-based
Memory	MEMORY.md + Honcho	MEMORY.md	Long-term memory
License	MIT	MIT	MIT
Language	Python	TypeScript	Python
Best for	Multi-platform agents	Developer workflows	Research & pipelines

Hermes Agent vs OpenClaw

Different audiences, overlapping capabilities. OpenClaw is the ecosystem leader with 160K stars, extensive extensions, and deep IDE integration. Hermes Agent is purpose-built for multi-platform messaging with the most comprehensive gateway in the space.

If you’re a developer wanting an AI coding agent in your terminal, OpenClaw is the clear choice. If you’re a community manager wanting an AI agent on Discord, Telegram, and Slack simultaneously, Hermes Agent is purpose-built for that. The hermes claw migrate command — which imports settings, memories, skills, and API keys from OpenClaw — shows NousResearch is explicitly positioning as a complementary tool for users who outgrow terminal-only workflows.

Hermes Agent vs DeerFlow 2.0

DeerFlow 2.0 is an autonomous task orchestrator built on LangGraph with multi-agent decomposition (Researcher, Coder, Reporter). It excels at long-running research pipelines, sandboxed code execution, and report generation.

Hermes Agent is a persistent server agent focused on multi-platform presence. DeerFlow gives you a task; Hermes gives you an always-on assistant. DeerFlow is better for “research this topic and build a report.” Hermes is better for “be available on all my messaging platforms 24/7.”

Hermes Agent vs Claude Code

Claude Code is a real-time interactive coding agent that lives in your terminal. Hermes Agent is a headless server agent that lives on your messaging platforms. They solve completely different problems. You’d use Claude Code to write and debug code in your IDE. You’d use Hermes Agent to manage your Discord community and automate cross-platform workflows. Many users run both.

OpenClaw Migration

Hermes Agent includes a built-in migration tool:

# Import from OpenClaw
hermes claw migrate

This command imports:

Settings — Configuration and preferences
Memories — MEMORY.md contents
Skills — Existing skill files
API keys — Provider credentials

The migration path is a deliberate positioning choice by NousResearch. They’re not trying to replace OpenClaw for coding tasks — they’re offering a complementary agent for users who want multi-platform presence alongside their existing dev tools.

Who Should Use Hermes Agent

Use Hermes Agent if you:

Manage Discord servers, Telegram groups, or Slack workspaces and want AI assistance
Need an agent that’s always on across 12+ messaging platforms simultaneously
Want model-agnostic flexibility with 200+ models via OpenRouter
Run a server or VPS and want a headless agent process
Want scheduled automations delivered to your preferred messaging platform
Need an agent that improves its own capabilities over time
Want Mixture of Agents consensus for high-stakes decisions

Skip Hermes Agent if you:

Want a coding assistant for daily development (use Claude Code or Cursor)
Need something that works on Windows without WSL2
Don’t want to manage API keys and bot tokens
Are looking for a polished consumer product with zero configuration
Need real ML-based learning, not markdown-based memory
Want the largest possible community and extension ecosystem (OpenClaw has 12x the stars)

FAQ

Is Hermes Agent free?

Yes. Hermes Agent is MIT licensed and completely free to use, modify, and distribute. You’ll need API keys for your model provider — OpenRouter, Anthropic, OpenAI, etc. — which have their own pricing. If you run the Hermes-4-405B model locally (you’ll need serious hardware for a 405B parameter model), the only cost is compute. For most users, OpenRouter with a budget model is the most practical approach.

How is Hermes Agent different from a Discord bot?

A Discord bot runs custom code on a single platform. Hermes Agent is a general-purpose AI agent that happens to connect to Discord — plus 11 other platforms. It maintains persistent memory across all platforms, creates and refines its own skills, executes code in sandboxed backends, runs scheduled automations, and can spawn subagents for complex tasks. It’s the difference between a script and an autonomous system.

Can I use Hermes Agent with local models?

Yes. Hermes Agent works with any model accessible via an OpenAI-compatible API. You can run local models through Ollama, vLLM, or similar inference servers. However, the Hermes-4-405B model that the agent is optimized for requires significant hardware — a 405B parameter model needs multiple high-end GPUs. Smaller local models will work but may produce lower-quality results for complex agentic tasks.

Does the agent actually “learn” or is it just saving notes?

Honest answer: it’s saving notes. The skills system writes structured markdown files. The memory system writes to MEMORY.md and USER.md. There are no embeddings, no vector stores, no gradient updates. What makes it effective is that the note-taking is well-engineered — atomic writes, injection scanning, automatic skill loading based on task similarity. It’s the best possible version of “structured prompt injection with a CRUD layer,” as critics describe it. For practical purposes, the agent does get better at recurring tasks. It’s just not ML-based improvement.

How does Mixture of Agents work in practice?

When enabled, Hermes Agent sends your prompt to 4 frontier models (Claude, Gemini, GPT, DeepSeek) simultaneously. It waits for all 4 responses, then feeds them to a 5th aggregator model that synthesizes a consensus answer. This costs 5x the API calls of a single model query, so it’s not something you’d use for every message. It’s best reserved for high-stakes decisions where you want multiple perspectives. The implementation is approximately 550 lines based on the published MoA research paper.

Is Hermes Agent trying to replace OpenClaw?

No — and NousResearch appears to know this. The hermes claw migrate command imports your OpenClaw configuration rather than asking you to abandon it. Hermes Agent fills a different niche: multi-platform presence and always-on server agents. OpenClaw dominates the developer-in-terminal use case. Hermes Agent targets community managers, team coordinators, and anyone who needs AI on messaging platforms. Many users will run both.

Get started today:

# Install
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

# Setup and configure
hermes setup
hermes model

# Start chatting
hermes

# Or enable the full multi-platform gateway
hermes gateway setup
hermes gateway
hermes gateway install  # systemd service

Resources: