Hermes Agent vs Claude Code

Short answer: if the job is writing and changing code, use Claude Code — that comparison is not close. Hermes Agent is a persistent assistant. It keeps state across sessions, reaches you through Telegram or Discord, runs work on a cron, and can execute on a cloud VM instead of your laptop. Coding is one of the things it does. It is the whole of what Claude Code is, and focus shows.

The interesting question is the other one. If what you want is an assistant that persists and comes to you, Claude Code is a different shape and Hermes is the one worth reading about — with caveats below substantial enough to change your timing.

Two different jobs

Claude Code is, in Anthropic's description, "an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools." The unit of work is a repository: you start it in a directory and that directory is the context. The IDE extensions, desktop app and web sessions it has grown since are all still organised around a task in a codebase.

Hermes Agent is organised around a person. Nous Research's README states the goal without hedging:

It's not tied to your laptop — talk to it from Telegram while it works on a cloud VM.

Three mechanisms follow. A single gateway process fronts "Telegram, Discord, Slack, WhatsApp, Signal, and CLI." A built-in scheduler will "schedule tasks to run automatically with natural language or cron expressions," delivering results to any of those. And memory persists between sessions rather than being reassembled from the repo each time. None of that is a coding feature, which is the point: ask which is still running at 3am when a job fires, and only one is designed for the question.

What Claude Code added, and the line that survives

This comparison would have been easier a few months ago, because Claude Code has moved onto ground that used to be Hermes's alone. Channels, a research preview as of 2026-07-31, put Telegram, Discord and iMessage in front of it, with sender allowlists and pairing codes. Routines went further than most people realise: they "execute on Anthropic-managed cloud infrastructure, so they keep working when your laptop is closed," on a schedule, an HTTP trigger, or a GitHub event. That is a genuine cron on a machine you do not own, and it removes the easy version of this comparison.

Two sentences in Anthropic's documentation mark where the difference actually sits. The first is about Channels:

Events only arrive while the session is open, so for an always-on setup you run Claude in a background process or persistent terminal.

The second is about Routines, and it is the sharper one. A skill you keep in ~/.claude/skills/ is reported as not found when a routine invokes it, "because each routine run starts as a fresh remote session." Repositories are cloned at the start of every run.

So Claude Code's persistence is per-task and stateless by design: a clean session, a cloned repo, a saved prompt, a result — auditable, and it cannot drift. Hermes's is the other kind, one continuing identity that accumulates. Both are called "scheduling" and they wake up different things.

The self-evolution story is about a different repository

Almost every comparison of these two names DSPy and GEPA as the Hermes differentiator — an agent that evolves itself through reflective search. The shipped agent does not contain it.

That machinery lives in a separate repository, NousResearch/hermes-agent-self-evolution, created 2026-03-09, whose last push as of 2026-07-31 was 2026-06-17 — six weeks earlier. Its own status table marks Phase 1, skill files, as implemented, and phases 2 through 5 as "🔲 Planned." It is a pipeline that runs on Hermes from outside: read a skill, generate evals, optimise against execution traces, open a pull request against hermes-agent. Nothing in the agent's pyproject.toml, README or skills documentation references either library.

The real mechanism is more modest and worth knowing because it is switched on. A tool called skill_manage lets the agent create, update and delete its own skills as SKILL.md files under ~/.hermes/skills/, triggered by ordinary events: a task of five or more tool calls, recovering from a dead end, or you correcting its approach.

Both products have skills, both follow the agentskills.io open standard, both store them as SKILL.md. The honest comparison is who writes them. Claude Code's are authored by you and committed, in ~/.claude/skills/ or .claude/skills/; its nearest self-authoring is narrow and explicitly invoked, like /verify recording what worked. Hermes describes its default in one line:

By default the agent writes skills freely — including from the background self-improvement review that runs after a turn.

Whether that is the feature or the risk depends on your appetite for a tool that edits its own instructions while you are not watching. If it is the risk, the gate exists: skills.write_approval: true stages every write in ~/.hermes/pending/skills/ for /skills pending, diff, approve and reject. memory.write_approval does the same for memory.

Where the work runs, and what is guarding it

This is Hermes's strongest structural claim. The README counts "seven terminal backends — local, Docker, SSH, Singularity, Modal, Daytona, and Vercel Sandbox," with Daytona and Modal hibernating when idle. Execution location is configuration, not architecture, so the same agent runs on your laptop today and a $5 VPS tomorrow. It also spawns isolated subagents for parallel workstreams — the same fan-out idea as Claude Code's subagents, with the same appetite for tokens. Claude Code runs where you started it; reaching it from elsewhere means Remote Control or a cloud session, covered in our remote access guide.

The part to read before installing: the default local backend has no isolation. Hermes's own security table lists it as "None — runs on host." What stands in for a sandbox is an approvals layer: approvals.mode defaults to smart, using an auxiliary LLM to assess risk, auto-approving low-risk commands, auto-denying dangerous ones and escalating the rest to a prompt. The documentation is unusually direct about what that is worth. Of the file write guards:

it does not sandbox a hostile or compromised agent

And of the deny rules: "They are not a sandbox against a deliberately adversarial process." The container and cloud backends invert the model — Docker, Singularity, Modal, Daytona and Vercel Sandbox skip dangerous-command checks entirely, "because the container itself is the security boundary."

That candour is a credit to the project, but it prices the decision. If you want rules enforced outside the model's judgement, Claude Code's hook contract is the more specified mechanism today — and if you run Hermes on anything that matters, put it on a container backend rather than trusting smart on your host.

The number that should decide your timing

Hermes reached its first tagged release on 2026-03-12 and has published 23 releases since. Its own notes for v0.19.1 describe the ten days after v0.19.0 like this:

~2,789 commits · ~4,748 files changed · ~442,000 insertions · ~392,300 deletions

The same paragraph characterises the window as "dominated by bug-fix and salvage waves across the gateway, voice subsystem, desktop app, and installer." Roughly 442,000 lines in and 392,300 out in ten days is not a project settling down; it is one still finding its shape in public. Claude Code ships most weeks too — v2.1.220 as of this date — but not at that amplitude, and it does not describe its own release windows as salvage. That is about timing, not quality: a tool changing this fast is a poor thing to build a team process on this quarter, and a reasonable thing to run for yourself on a machine you can rebuild. Pin nothing to a version.

Issue counts need the same care in the other direction. With 26,035 open issues against 222,995 stars, reaction totals stop working as a severity signal — a real defect and a stale duplicate look alike. One issue that circulates in comparisons is #54722, on the agent reporting verified success after failed or unverified tool evidence. Read it in the reporter's own framing, "a design flaw with bug-level failure modes," and note that it is an unreproduced P2, opened 2026-06-29, with zero reactions.

How to pick

• You want code written and changed. Claude Code — a repository-shaped agent for a repository-shaped job, without a gateway, a scheduler and a memory system you did not ask for.
• You want to message your coding agent from your phone. Still Claude Code: Channels or Remote Control, given that a session has to be open. A second agent is a lot of machinery for a small want.
• You want something running when you aren't, with continuity between conversations. Hermes. This is what it is built for, and where Claude Code's design points elsewhere.
• You want unattended work on infrastructure you don't own. Both answer. Routines give a cloud cron with a fresh session each run; Hermes gives cloud backends carrying the same agent and its memory. Pick by whether you need continuity or auditability.
• Inference must not go to one vendor. Hermes is model-agnostic by construction, self-hosted runtimes included. Claude Code is Anthropic's client and talks to Anthropic.

Running both is cheap and fairly common: Hermes as the assistant that watches and schedules, Claude Code for the coding work when it lands. Setup for the Hermes half is in our Hermes Agent guide.

Sources

Versions, star counts, release notes and quoted documentation read on 2026-07-31. Quotations are verbatim from the pages linked below. Hermes in particular changes weekly; verify anything you plan to depend on.

• github.com/NousResearch/hermes-agent · v0.19.1 release notes · issue #54722
• Hermes — Skills · Memory · Security · Features overview
• NousResearch/hermes-agent-self-evolution — the separate DSPy/GEPA repository, and its phase table
• Claude Code — Channels · Routines · Skills · Overview
• npm registry — @anthropic-ai/claude-code (version and licence field)

Not affiliated with Nous Research or Anthropic. If something here is wrong or has gone stale, tell us and we'll fix it.