Forget Chatbots — Hermes Agent Is an AI That Actually Learns from You
aws

Forget Chatbots — Hermes Agent Is an AI That Actually Learns from You

Jahangir
0 comments

Three months ago, I’d never heard of Hermes Agent.

Today, it’s the fastest-growing open-source AI agent framework of 2026.

135,000+ GitHub stars in under 3 months 20+ messaging platforms— Telegram, Discord, Slack, WhatsApp, and more **MIT licensed **— fully self-hosted, zero telemetry, your data never leaves your machine

Built by Nous Research — the lab behind the Hermes, Nomos, and Psyche model families — this isn’t another chatbot wrapper or a coding copilot tethered to your IDE.

It’s an autonomous agent that lives on your server, remembers what it learns, and gets smarter the longer it runs.

A hands-on deep dive into Nous Research’s self-improving agent: deployment, daily usage, and the technical architecture that makes it genuinely different.

Last month, I stumbled across a GitHub repo that had quietly amassed over 60,000 stars in under three months. No VC hype cycle. No Product Hunt launch day theatrics. Just a curl command, a promise — “the agent that grows with you” — and a wildly active Discord.

That repo was Hermes Agent by Nous Research, and after spending the past several weeks deploying it, breaking it, rebuilding it, and watching it learn my workflows in real time, I’m convinced it represents a fundamentally different philosophy of what an AI agent should be.

This isn’t a review. This is a field report.

What Hermes Agent Actually Is

Let me clear something up immediately, because the AI agent space is drowning in language that means nothing: Hermes Agent is not a chatbot wrapper. It is not a coding copilot bolted onto your IDE. It is not another skin over the OpenAI API.

Hermes Agent is a persistent, self-hosted, autonomous AI agent that lives on your own server — a $5 VPS, a beefy GPU workstation, or a serverless backend that hibernates when idle. You install it once. You give it access to your messaging platforms. And then, critically, it stays running. It remembers what you told it last Tuesday. It remembers the deployment script it wrote for you three weeks ago. It gets measurably better at your specific workflows the longer you use it.

By May 2026, it was processing over 224 billion daily tokens on OpenRouter and sitting at the #1 global daily rank across productivity, coding agents, personal agents, and CLI agents.

Those aren’t vanity metrics. That’s real adoption, and after deploying it myself, I understand why.

Part 1: Deploying Hermes Agent (It’s Almost Too Easy)

Prerequisites: Basically Nothing

One of my biggest pet peeves with open-source agent frameworks is the dependency nightmare. Twenty minutes into installation you’re debugging a Python version conflict while questioning your life choices.

Hermes doesn’t do that. The installer handles everything: uv, Python 3.11, Node.js, ripgrep, ffmpeg, and on Windows it even unpacks a portable Git Bash so you don't need admin privileges. The entire philosophy is "one command, zero prerequisites."

Step 1 — Install

On my Ubuntu 24.04 VPS (a modest 2-core, 4GB RAM machine), the entire install was:

bash

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

That’s it. The script cloned the repo, set up a virtual environment, installed all dependencies, and dropped me at a ready state in about two minutes. No sudo needed.

For Windows users, there’s a PowerShell equivalent (irm ... | iex), though the team is transparent that native Windows support is still early beta — WSL2 is the battle-tested path.

Step 2 — Configure

bash

hermes setup

This launches an interactive setup wizard that walks you through:

  • Choosing your model provider. I started with Nous Portal (their OAuth-based endpoint), but you can point it at OpenRouter (200+ models), OpenAI, NVIDIA NIM, Hugging Face, a local Ollama instance, or literally any OpenAI-compatible endpoint. Switching later is as simple as hermes model — no code changes.
  • Connecting messaging platforms. I wired up Telegram and Discord on day one, then added Slack later. The wizard handles bot tokens, webhook URLs, and platform-specific quirks.
  • Selecting a terminal backend. This is where it gets interesting. Hermes supports seven execution backends: local, Docker, SSH, Singularity, Modal, Daytona, and Vercel Sandbox. I went with Docker for sandboxing, but Modal and Daytona offer something special — serverless persistence, where your agent’s environment hibernates when idle and wakes on demand, costing nearly nothing between sessions.

Step 3 — Launch

bash

hermes

That opens the full interactive TUI — multiline editing, slash-command autocomplete, conversation history, streaming tool output. It felt immediately polished in a way I didn’t expect from an open-source CLI tool.

For persistent server deployment (which is the whole point), I set it up as a systemd service so it survives reboots and runs 24/7:

bash

hermes gateway start

The gateway is what connects all your messaging platforms to the running agent. Start it, walk away, and message your agent from Telegram while it works on a cloud VM.

My Deployment Verdict

From curl to a working agent responding on Telegram: under 10 minutes. I've spent longer configuring a .eslintrc.

Part 2: Using Hermes Agent in the Real World

Here’s where the article shifts from “how to install a thing” to “why I’m still using it weeks later.” Let me walk through the scenarios that convinced me this is genuinely different.

Scenario 1: The Agent That Remembers

On day three, I asked Hermes to help me write a deployment script for a side project. It asked about my infrastructure, wrote the script, tested it in a sandboxed Docker terminal, and pushed a working version.

Two weeks later, I said: “Hey, update the deployment script for the new staging environment.”

It didn’t ask me what deployment script. It didn’t need a file path. It searched its own conversation history using FTS5 full-text search, found the original session, loaded the relevant context, and updated the script with the new environment variables. Zero hand-holding.

This is the persistent memory layer in action. Hermes stores everything — memories, skills, conversation history — in a local SQLite database on your machine. Nothing leaves your server. No telemetry, no tracking, no cloud lock-in. It uses two key files:

  • **MEMORY.m**d — Long-term facts and knowledge the agent has accumulated
  • **USER.m**d — A deepening model of you: your preferences, your projects, your conventions

The agent curates these itself through periodic “nudges” — moments where it decides something is worth persisting for the long term.

Scenario 2: Skills That Write Themselves

This is the feature that broke my brain a little.

After I asked Hermes to set up a monitoring pipeline for one of my services (a multi-step process involving Prometheus config, Grafana dashboards, and alert rules), it completed the task in about 15 tool calls. Then, unprompted, it entered a reflection phase.

It reviewed what it had just done, identified the reusable patterns, and generated a skill document — a structured markdown file capturing the procedure, the common pitfalls, and the verification steps. It saved this as ~/.hermes/skills/devops/monitoring-pipeline/SKILL.md.

The next time I asked for a similar setup on a different project, it loaded that skill, adapted the variables to the new context, and completed the task in roughly half the time with zero errors.

This isn’t template reuse. The agent dynamically adjusts variables within skills based on new context parameters. And it can improve existing skills during future runs — if it discovers a better approach, it patches the skill document using a token-efficient diff operation rather than rewriting the whole thing.

The skill system uses a three-level progressive loading strategy to keep token costs sane:

  • Level 1: Skill name and brief description (~20 tokens)
  • Level 2: Detailed description and parameter specs (~200 tokens)
  • Level 3: Full execution steps and tool call sequences (~1,000+ tokens)

It only loads what it needs, when it needs it.

Scenario 3: Scheduled Automations in Plain English

One morning, I typed into Telegram:

“Every Monday at 8am, pull the latest error logs from production, summarize anything critical, and send me a digest here.”

Hermes created a cron job. Not a cron expression I had to debug — a natural language schedule that it translated internally into a proper schedule format. The job runs unattended through the gateway, and every Monday I get a concise error digest in my Telegram chat before I’ve finished my coffee.

This works because Hermes has first-class scheduled jobs that store in JSON, support multiple schedule formats, can attach skills and scripts, and deliver results to any connected platform.

Scenario 4: Subagents and Delegation

For a complex data migration, I needed to run multiple tasks in parallel — validating schemas, transforming records, and running integrity checks. Instead of me orchestrating this, Hermes delegated.

It spawned isolated subagents, each with their own conversations, terminals, and Python RPC scripts. These subagents run in separate contexts (zero context cost to the parent agent) and report back when done. The v0.13.0 release added durable Kanban boards for multi-agent task monitoring, complete with heartbeat checks, zombie detection, and automatic retries.

I watched on the dashboard as three subagents worked simultaneously, each in their own Docker container, each reporting progress to a shared Kanban. When one hit an error, Hermes automatically retried with a modified approach. The parent agent synthesized the results and gave me a single summary.

Part 3: Technical Deep Dive — What Makes Hermes Architecturally Different

Now for the part that made me fall down a rabbit hole for several evenings. The architecture of Hermes Agent is surprisingly principled for a project that moves this fast (864 commits and 588 merged PRs in the v0.13.0 cycle alone).

Three-Tier Architecture

Hermes follows a clean three-tier separation:

  • Interface Layer — CLI/TUI, messaging platform adapters (Telegram, Discord, Slack, WhatsApp, Signal, Matrix, Email, and 20+ others), editor integrations via the Agent Client Protocol (ACP)
  • Core Agent Layer — Conversation orchestration, prompt assembly, tool dispatch, memory management, skill system
  • Execution Layer — Terminal backends (local, Docker, SSH, Singularity, Modal, Daytona, Vercel Sandbox)

The critical design rule: the agent doesn’t know which interface it’s running behind. All platform specifics live in adapters that translate platform events into agent.run_conversation(...) calls and translate the response back. The moment you add a Telegram-specific if branch inside core agent code, you've broken the architecture.

Prompt Assembly — The Real Engine

The prompt_builder.py is where the magic happens. At session start, it assembles a system prompt from:

  • **SOUL.m**d — The agent's personality and behavioral guidelines
  • **MEMORY.md / USER**.md — Persistent facts and user model
  • Skills index — Available skills with their progressive loading levels
  • Context files — AGENTS.md, .hermes.md, project-specific instructions
  • Tool-use guidance — Model-specific instructions for tool calling
  • Model-specific instructions — Tailored prompting for different model architectures

One crucial detail: the system prompt is assembled once at session start and does not mutate mid-conversation. This isn’t an aesthetic choice — it’s an economic one. Anthropic-style prompt caching (which Hermes supports via prompt_caching.py) only works when the prefix is stable. Mutating the system prompt mid-conversation would bust the cache and double your API costs.

When conversations grow long, context_compressor.py summarizes middle turns to keep the context within model limits without losing critical information.

The Closed Learning Loop

This is the single most differentiating architecture in Hermes, and it’s worth understanding the full cycle:

Observe → Execute → Reflect → Crystallize → Reuse
   ↑                                           │
   └──────────── Automatically invoked ─────────┘
  • Observe: The agent receives a task and assesses available skills and context
  • Execute: It completes the task using tools (70+ registered across ~28 toolsets)
  • Reflect: After complex tasks (5+ tool calls), it reviews what worked and what didn’t
  • Crystallize: It saves reusable patterns as skill documents
  • Reuse: Next time a similar task appears, it loads the skill and improves upon it

All memory entries undergo security scanning before storage, detecting potential prompt injection attacks and data exfiltration patterns. This isn’t security theater — the skill system operates on agent-generated content that could theoretically be influenced by adversarial inputs in web content or user-provided files.

Tool Registry

The central tool registry (tools/registry.py) manages 70+ registered tools across roughly 28 toolsets. Each tool file self-registers at import time. The registry handles schema collection, dispatch, availability checking, and error wrapping. Tools span web search, browser automation, vision, image generation, TTS, file operations, code execution, and memory/planning operations.

Beyond built-in tools, Hermes supports MCP (Model Context Protocol) for connecting to any external MCP server, and it exposes four plugin hooks: pre_llm_call, post_llm_call, on_session_start, and on_session_end. You can extend the agent without forking the codebase.

Sandboxing and Security

This is where Hermes takes a more restrained approach than some competitors. The documentation describes:

  • Container hardening with read-only root filesystems
  • Dropped capabilities and namespace isolation
  • Filesystem checkpoints and rollback
  • Pre-execution scanning for terminal commands
  • Seven terminal backends with varying isolation levels

The philosophy is controlled execution first, marketplace scale second. That restraint isn’t cosmetic — it fundamentally changes the risk profile when you’re running an autonomous agent with shell access on your infrastructure.

Research-Ready Infrastructure

This is the part that reveals Hermes is built by a model training lab, not just a product team:

  • Batch trajectory generation — Generate thousands of tool-calling trajectories in parallel with automatic checkpointing
  • 11 tool-call parsers — For training any model architecture
  • ShareGPT export — Convert conversations into fine-tuning data
  • Trajectory compression — Fit training data into token budgets
  • Atropos integration — Reinforcement learning on agent behaviors

Hermes isn’t just an agent — it’s a data flywheel for training better tool-calling models. Every interaction can become training data. This is, arguably, the real strategic point of the project for Nous Research.

Part 4: What I’d Improve

No field report is honest without friction. Here’s what I ran into:

  • The learning curve for skill curation is real. The agent creates skills autonomously, but not all of them are good. I found myself periodically pruning ~/.hermes/skills/ to remove skills that were too narrow or encoded bad assumptions. The team recommends treating USER.md and MEMORY.md as "high-signal infrastructure" — concise, durable, preference-focused — and I agree, but it takes some intentional gardening.
  • Model choice matters more than you’d think. Hermes is model-agnostic, which is a strength, but the quality of the self-improvement loop varies dramatically between models. Larger models (Claude, GPT-4 class) produce better skill documents and more nuanced memory entries. Smaller local models work fine for execution but the reflection phase can be shallow.
  • Multi-agent coordination is powerful but opaque. The Kanban boards help, but when three subagents are running simultaneously in Docker containers, debugging a failure in one requires digging through individual session logs. Better observability tooling would help here.

Final Thoughts: Why This Matters

The AI agent space in 2026 is noisy. Everyone has a framework, everyone has a wrapper, everyone has a demo that looks amazing in a two-minute video.

Hermes Agent is different because it’s built on a genuinely different thesis: the value of an agent comes not from the smartness of a single inference call, but from the compounding effect of memory, workflow recovery, tool orchestration, and repeatability over time.

Frontier model performance is converging. The gap between the top providers is measured in single-digit Elo points. When the models themselves are increasingly commoditized, the moat moves to the agent layer — to how well the system remembers, learns, recovers, and adapts.

Hermes Agent is the most credible open-source implementation of that thesis I’ve seen. It’s MIT licensed, self-hosted, and genuinely free. Your data never leaves your machine. And it gets better the longer you use it — which is more than I can say for most software I interact with daily.

Install it. Give it a week. Let it learn you.

If you found this useful, follow me for more hands-on deep dives into the tools actually worth your time. Got questions about my Hermes setup? Drop them in the comments.

Comments

Loading comments…