NousResearch's Hermes-Agent: The AI That Learns Your Preferences Over Time

Hermes-Agent from NousResearch is an open-source autonomous AI agent that solves the fundamental limitation of stateless AI assistants: the amnesia problem. It maintains three tiers of persistent memory, integrates the Honcho user-modeling engine to build an evolving psychological profile of each user, and writes its own reusable skills—becoming more capable and more yours the longer it runs.

What Is Hermes-Agent?

NousResearch, the independent AI lab behind the Hermes model family, released Hermes-Agent in February 2026 as an open-source autonomous agent framework. Where coding copilots remain tethered to an IDE and chatbots reset with every new tab, Hermes-Agent runs persistently on your own infrastructure—from a $5 VPS to a serverless cloud—and accumulates context across every interaction.¹

The pitch is precise: an assistant that isn’t just powerful in isolation, but one that compounds in usefulness over time. In two weeks following the initial v0.1.0 release, the project received 216 merged pull requests from 63 contributors, resolving 119 issues—signaling unusually rapid open-source traction for an agent framework.²

The v0.2.0 release (March 12, 2026) added multi-platform messaging support across Telegram, Discord, Slack, WhatsApp, Signal, and email via IMAP/SMTP; native Model Context Protocol (MCP) integration; over 70 bundled skills across 15+ categories; and editor integration for VS Code, Zed, and JetBrains via the Agent Communication Protocol (ACP).² The test suite expanded from near-zero to 3,289 tests covering agent logic, gateway platforms, tools, cron jobs, and CLI behavior.

How Does Hermes-Agent Build a Model of You?

Hermes-Agent’s personalization operates through four distinct, layered mechanisms that interact at runtime:

1. Three-Tier Memory Architecture

The agent maintains three categories of memory with clearly defined roles:

• Session memory: Standard conversation context within the current interaction
• Persistent memory: Facts, preferences, environment details, and project locations stored in MEMORY.md (~2,200 character bounded) and USER.md (~1,375 characters) that survive across sessions
• Skill memory: Procedural knowledge encoded as reusable skill files in the ~/.hermes/skills/ directory—written autonomously by the agent when it solves complex problems⁴

When persistent memory fills, the agent consolidates entries rather than silently dropping them—preserving the most informative facts about your working style and environment.

2. Honcho Dialectic User Modeling

The most architecturally distinctive component is the integration of Honcho, an open-source user-modeling library from Plastic Labs that applies theory-of-mind reasoning to build psychological profiles of users over time.⁵

Honcho operates asynchronously: as sessions are created and messages logged, the system reasons about user psychology in the background, deriving facts about preferences, communication style, domain expertise, and work patterns. These are stored as structured data queryable via natural language at session start.

Plastic Labs raised a $5.4M pre-seed led by Variant, White Star Capital, and Betaworks to develop Honcho specifically as infrastructure for personalized AI agents—framing the problem not as “memory” but as identity modeling.⁵ Their architecture treats users, agents, and external systems as equal “Peers” with persistent state, moving away from the transient user-assistant paradigm.

3. SOUL.md and the Personality Stack

Hermes-Agent separates what it knows about you from how it speaks to you through a three-layer personality stack:

1. ~/.hermes/SOUL.md: A global persona file injected verbatim into the system prompt at session start. Defines communication style, tone, and directness across all interactions.⁴
2. /personality overlays: Temporary session-level mode switches (presets include “technical,” “creative,” “teacher,” and others)
3. AGENTS.md: Project-specific conventions that shape behavior per deployment directory

SOUL.md is intentionally permanent—“if it should follow you everywhere, it belongs in SOUL.md”—while project context files are scoped to individual working directories.

4. Autonomous Skill Creation

When Hermes-Agent navigates a complex multi-step task, it writes a new skill document describing the approach in a format compatible with the agentskills.io open standard. Skills self-improve during subsequent uses. The agent also receives periodic internal nudges to persist knowledge before context fills—a form of automated metacognitive prompting.¹

The skills ecosystem supports community sharing via a Skills Hub, allowing practitioners to import and export procedural knowledge across deployments.

# Start Hermes-Agent and it will automatically load SOUL.md,
# MEMORY.md, USER.md, and project context files
hermes

# Check current personality overlay
/personality

# Switch to technical communication mode
/personality technical

# View current memory contents
/memory show

Why Does Hermes-Agent Matter?

The Comparison Landscape

Hermes-Agent occupies a distinct position relative to existing alternatives:

The differentiator isn’t any single capability—it’s the closed learning loop. Honcho models the user, MEMORY.md retains factual context, skills encode procedural knowledge, and SOUL.md shapes communication style. These components interact at every session, compounding rather than operating independently.

The Research Foundation

Academic work published in late 2025 validates the architectural direction. The Memoria framework paper (arXiv 2512.12686) demonstrates that agentic memory systems using weighted knowledge graphs for user modeling outperform static retrieval approaches on personalization tasks.⁶ Research on enabling personalized long-term LLM agent interactions (arXiv 2510.07925) shows that integrating dynamic user profiles with persistent memory enables agents to reduce clarification rounds and improve task completion rates on longitudinal benchmarks.³

Hermes-Agent’s implementation maps closely to these findings: Honcho’s async psychological profiling parallels the knowledge-graph user modeling described in Memoria, while the FTS5 full-text search with LLM summarization for cross-session recall implements the episodic memory retrieval patterns identified in the “Memory in the Age of AI Agents” survey (arXiv 2512.13564).⁷

Technical Architecture Under the Hood

The core agent loop runs as the AIAgent class in run_agent.py, handling provider/API-mode selection, prompt construction, tool execution, retries and fallback, callbacks, compression, and persistence synchronously.⁸ The prompt system maintains stability throughout execution, injecting SOUL.md, context files, memory entries, and skills guidance at session initialization.

Session state lives in SQLite with lineage preserved across compression splits—meaning even as context windows fill and get compressed, the thread of a multi-week project remains traceable. System prompts and prefill messages are injected at API call time and are never persisted to the database or logs, preventing prompt leakage.

The provider layer supports Nous Portal, OpenRouter, and any OpenAI-compatible API, making the Hermes base model optional. The v0.2.0 release adds a centralized provider router replacing scattered provider logic with “automatic credential resolution” across vision, summarization, compression, and trajectory saving operations.²

An included reinforcement learning framework provides environment infrastructure for evaluation, RL training, and trajectory capture—indicating NousResearch’s longer-term direction toward agents that improve through interaction data, not just preference accumulation.

# Hermes-Agent memory files use a simple Markdown structure
# ~/.hermes/MEMORY.md — facts about environment and workflow
"""
- Primary language: Python, prefers type hints
- Project root: ~/projects/api-service
- Database: PostgreSQL 16, local dev on port 5433
- Prefers short terminal output, avoids verbose flags
- Uses pytest, not unittest
"""

# ~/.hermes/USER.md — preferences and working style
"""
- Direct communication, skip preamble
- Explain before changing production files
- Ask before deleting anything
- Prefers incremental commits over large changesets
"""

What’s Proven Versus Promised

The personalization architecture is technically sound and demonstrably implemented: SOUL.md injection, bounded persistent memory with consolidation, FTS5 cross-session recall, Honcho integration, and autonomous skill creation are all documented, open to inspection, and covered by the test suite.

What remains to be established by independent evaluation:

• Longitudinal accuracy: Whether Honcho’s user modeling actually improves task outcomes over 30–90 day usage windows
• Skill quality degradation: Whether autonomously-generated skills accumulate technical debt or conflicting procedures at scale
• Memory consolidation fidelity: Whether critical preferences survive repeated consolidation cycles without semantic drift

These are tractable questions that practitioners running Hermes-Agent over extended periods will answer empirically. The architecture makes them answerable—which is itself a meaningful advance over black-box alternatives.

Frequently Asked Questions

Q: What infrastructure does Hermes-Agent require to run? A: It runs on any POSIX-compatible system including a $5 VPS, local machine, Docker, SSH, Singularity, or serverless backends like Modal and Daytona. A persistent process is required for the multi-platform messaging gateway; CLI usage is stateless at the process level but persists to SQLite.

Q: Is Hermes-Agent tied to any specific LLM provider? A: No. It connects to Nous Portal, OpenRouter, or any OpenAI-compatible API, meaning you can run it against Hermes 4 models, Claude, GPT-4o, or local models through compatible inference servers.

Q: How does Honcho user modeling differ from simple memory retrieval? A: Standard memory retrieval stores and fetches text. Honcho applies theory-of-mind reasoning asynchronously to derive structured facts about user psychology—preferences, work patterns, domain expertise—that inform system prompt construction at session start, not just ad-hoc retrieval.

Q: What happens when MEMORY.md fills up? A: The agent consolidates entries, merging or discarding lower-signal facts to maintain the character limit. This prevents unbounded accumulation and maintains information density, though it means very old low-priority entries may not survive indefinitely.

Q: Can skills created by one user be shared with others? A: Yes. Skills conform to the agentskills.io open standard and can be shared via the community Skills Hub. The v0.2.0 release also imports skills from legacy systems into ~/.hermes/skills/openclaw-imports/ for users migrating from other frameworks.

Sources:

• GitHub - NousResearch/hermes-agent
• Hermes Agent — AI Agent Framework
• Hermes Agent Documentation
• Release v2026.3.12
• Nous Research Releases Hermes Agent — MarkTechPost
• Hermes Agent: Self-Improving AI with Persistent Memory — YUV.AI
• GitHub - plastic-labs/honcho
• Launching Honcho — Plastic Labs Blog
• arXiv: Memoria Framework (2512.12686)
• arXiv: Personalized Long-term LLM Interactions (2510.07925)
• arXiv: Memory in the Age of AI Agents (2512.13564)
• Hermes Agent Architecture Docs