Hermes Desktop: The MIT-Licensed Agent That Remembers Everything Between Sessions

Every AI coding session has a dirty secret: it starts from zero. Open Claude Code, open Cursor, open anything — you re-explain the project, re-load the context, re-negotiate the conventions you agreed on last Tuesday. The model is fresh. You are not. Nous Research's Hermes Agent attacks this directly. Its core premise is that agent state should survive restarts, and on June 5 the team shipped a native desktop app that makes this feel like a first-class product rather than a research prototype.

One hundred PRs and 159 commits landed in a single week. That's an unusual ship velocity for a team that also maintains 26+ model provider integrations and an MIT-licensed codebase. Here's what actually shipped and why it matters for developers running long-horizon work.

The gap every agent leaves open

Agents are excellent at discrete tasks. Tell Claude Code to add OAuth, it does. Tell Cursor to fix the flaky test, it does. The unit of work fits inside one conversation window and the agent closes when it's done.

The trouble starts when the task isn't discrete. A six-week migration. A product redesign with fifty moving pieces. A refactor that needs to happen across 14 pull requests. These don't fit in a single session, and today's agents have no concept of continuity across sessions. You either write the handoff notes yourself (and they drift), or you start from scratch every morning.

What Hermes actually is

Hermes Agent is a runtime layer, not an IDE replacement. Nous Research positions it as a complement to Claude Code and Codex rather than a competitor. The distinction is architectural: where Claude Code and Cursor focus on within-session quality — accurate edits, tight tool-call control, deep model integration — Hermes focuses on cross-session durability.

The agent reads context from a stack of standard files it recognizes: .hermes.md, AGENTS.md, CLAUDE.md, and .cursorrules. It respects whichever conventions your team already uses. If you've already written a CLAUDE.md for Claude Code, Hermes picks it up without modification.

The Surface Release: native desktop in one week

Before June 5, Hermes was primarily a terminal and TUI experience. The Surface Release changed that with a full Electron-based desktop application shipping cross-platform: macOS, Linux, and Windows.

The feature surface is exactly what you'd want from a first-class desktop app. Streaming chat windows with session archive and search, drag-and-drop file support, clipboard image pasting, and a Cmd+K command palette. What makes this more than a pretty wrapper is the remote gateway model: the GUI runs locally but the agent compute can live on a remote instance, connected over a secure WebSocket with OAuth or password auth.

That architectural separation matters. It means a lightweight laptop can front-end a Hermes instance running on a beefy workstation or a cloud VM, with no local resource overhead. The thin-client pattern is familiar from Cursor's remote SSH mode but goes further here because the agent runtime itself is remote, not just the filesystem.

Durable goals, kanban, and checkpoints

This is the core differentiator. Hermes ships three persistence primitives that together give you something closer to a project management layer than a chat interface.

Persistent goals

A /goal is a standing objective that survives restarts. When you set one, Hermes runs a judge model after each turn to check whether the goal has been satisfied, up to a configurable maximum (default 20 turns). The goal persists in local storage and resumes automatically the next time you open the session. No re-briefing required.

Durable kanban

Tasks are backed by local SQLite, not in-memory state. Each task has heartbeat monitoring and zombie detection — if an agent process dies mid-task, the task doesn't vanish. It stays in the board, marked stalled, ready for resumption. Cross-agent task handoffs work through the same store, so a Hermes instance can pick up work that a different agent or session started.

# project memory

## active goals
- [ ] migrate auth layer to Better Auth (target: PR #114)
- [ ] reduce API response time on /skills endpoint below 200ms

## conventions
- Always use `select` not `include` on Prisma queries
- Commit messages follow conventional commits

## session log
### 2026-06-07
- Implemented OAuth flow, blocked on cookie domain issue
- Next: investigate cross-subdomain cookie strategy

Checkpoints

Checkpoints v2 takes automatic snapshots before any destructive operation — file deletions, large rewrites, database migrations. The /rollback command lets you restore a prior state or preview the diff before committing. This is the safety net that makes persistent, multi-day agents actually trustworthy: you can let the agent run unsupervised on long tasks knowing there's a clean undo path.

Install in under five minutes

The fastest path on macOS or Linux is the shell installer. Windows users need WSL2 for now (native Windows support is on the roadmap).

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

# First-time setup: picks your default model provider
hermes setup

# Open the desktop app (if you installed the Surface Release)
# Or run as a TUI
hermes

The fuzzy model picker during setup surfaces 26+ provider options. The catalog refreshes hourly — new models like deepseek-v4-flash and qwen3.7-plus appear as soon as they go live, without a CLI update. If you want to route through Anthropic, point it at Claude Opus or Sonnet via the provider picker.

Hermes alongside Claude Code and Cursor

The practical workflow most teams land on treats Hermes as the persistence layer and Claude Code or Cursor as the execution layer. The division of labor is clean: Hermes holds the project memory, tracks goals and tasks across sessions, and manages the multi-day arc of a feature. Claude Code handles the precise, within-session coding work where its tool-call quality, subagent support, and deep model integration shine.

Because Hermes reads CLAUDE.md and Claude Code reads CLAUDE.md, the two share a convention layer automatically. Write your project context once, both agents use it.

# Typical dual-agent session workflow

# 1. Open Hermes at project start — load goals, review kanban
hermes goal status

# 2. Hand a specific task to Claude Code for execution
# (Claude Code picks up CLAUDE.md conventions automatically)
claude "implement the cookie domain fix from the session log"

# 3. After Claude Code finishes, record the outcome in Hermes
hermes task close "cookie-domain-fix" --note "fixed, PR #112 open"
hermes goal check  # judge model verifies goal completion

The open-source nature of Hermes also means this integration pattern can be automated. A SKILL.md skill that runs the goal-check and session-log update at the end of every Claude Code session is a two-day project. Browse the productivity category on skills-hub.ai for building blocks, or install the session-memory skill we published alongside this post.

The broader pattern here is worth naming. The 2026 AI coding stack isn't one tool that does everything — it's a set of tools with distinct responsibilities, composing cleanly because they share open standards. CLAUDE.md, AGENTS.md, and SKILL.md are the connective tissue. Hermes Desktop is the first tool in the ecosystem to make cross-session persistence a first-class GUI concern rather than a terminal afterthought.

For teams running long-horizon work — migrations, redesigns, anything that spans more than a week of agent time — it's worth 20 minutes to install Hermes and see whether the persistent goal layer changes how you plan. The MIT license means the investment is just time.

# One command to try it
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash && hermes setup

Related reading: Claude Code Subagents guide, the AI coding stack post, and the agent teams pattern guide if you're designing multi-tool pipelines.