Hermes Agent v0.13.0 'The Tenacity Release': What Shipped on May 7

On May 7, 2026, Nous Research tagged Hermes Agent v0.13.0 as v2026.5.7 and called it "The Tenacity Release." The name is well-chosen: nearly every shipped change is about not giving up — on a task, on a goal, on an in-flight gateway connection, on a partially-completed write.

If you run Hermes on a VPS as your always-on agent, this is the release that finally treats long-running work as a primary use case.

Key Takeaways

• v0.13.0 / v2026.5.7 / "The Tenacity Release" shipped May 7, 2026.
• Durable Kanban is a SQLite-backed task board that survives restarts, agent boundaries, and human handoffs.
• Persistent /goal lets you set a target state and Hermes keeps working across sessions until it is met.
• Checkpoints v2 is a structured snapshot system with /rollback to return the agent to a prior known-good state.
• Gateway auto-resume means a dropped Telegram/Slack/etc. connection re-establishes without losing the in-flight conversation.
• Post-write linting runs declared linters after Hermes writes a file, so it catches its own syntax mistakes inline.
• Eight P0 security fixes ship in the same release; upgrade promptly.
• Self-hosted on a $5 VPS, the upgrade is a single pip install -U hermes-agent followed by a service restart.

The Headline: Hermes Now Remembers What It Was Doing

Before v0.13.0, Hermes was already persistent in the "long-running server process" sense. It kept memory, it kept skills, it kept open gateway connections. But it did not keep a structured view of the work in progress. If you asked it to "ship the redesign and let me know when it's done," the only place that goal existed was in the chat transcript.

Three changes in v0.13.0 fix this together: Kanban, persistent /goal, and Checkpoints v2. They are easier to understand as a single mental model:

Goal:        the outcome you asked for
Kanban:      the work you've broken it into
Checkpoints: snapshots you can return to if a branch goes wrong

You set a goal. Hermes decomposes it into Kanban cards. As it works, it snapshots progress. If a branch goes off the rails, /rollback returns to a prior checkpoint and tries a different approach. The goal remains intact across all of this.

Durable Kanban

The Kanban board is backed by a local SQLite database. Each card has:

• A title and description.
• A state: backlog, in_progress, blocked, review, done.
• An owner: hermes, claude-code-subagent, human, or a named teammate.
• A linked goal (optional).
• A trail of agent reasoning, tool calls, and human comments.

Two things make this useful in practice:

1. It survives restarts. Reboot the VPS, restart the Hermes process, lose your laptop battery — the Kanban state persists.
2. It crosses agent boundaries. Hand a card from Hermes to Claude Code (via the spawning Claude Code as a subagent pattern), or to a human reviewer. The state of the card travels.

A typical interaction:

> /kanban list in_progress
[CARD] Migrate auth to better-auth — owner: claude-code-subagent
       └─ Last update: passing 87/90 tests, waiting on signature change
[CARD] Draft May newsletter — owner: human
       └─ Blocked on Q2 numbers from analytics

Persistent /goal

/goal is not new in agent runtimes — Claude Code shipped its own goal command in early 2026. Hermes' contribution is making the goal persistent. It survives session boundaries.

> /goal "Ship the redesign to staging this week"
Goal set. Working until met or until you cancel with /goal clear.

From that point, every Hermes session knows the active goal. Kanban cards link to it. Memory writes tag it. The agent's planning loop uses it as the terminal condition.

This pairs well with Hermes' push-to-talk voice mode: you set a goal from your phone on a morning walk, and Hermes works against it for the rest of the day. You check in via Telegram or Slack without losing thread.

Checkpoints v2 and /rollback

Checkpoints are snapshots of agent state at a particular moment. v0.13.0 introduces a structured format:

checkpoint:
  id: ck_2026_05_07_abc
  taken_at: "2026-05-07T14:22:01Z"
  trigger: pre_destructive_action
  contents:
    - workdir_diff
    - kanban_state
    - goal_state
    - memory_index
    - tool_history_tail: 50

Checkpoints fire automatically before destructive actions (anything that writes outside the working dir, runs rm, calls a high-risk capability, etc.) and on explicit /checkpoint. /rollback returns to the most recent checkpoint or a named one.

This is the safety net that makes autonomy bearable. Hermes can take a riskier branch knowing the cost of being wrong is bounded.

Gateway Auto-Resume

If you use the eight Hermes messaging gateways — Telegram, Discord, Slack, WhatsApp, Signal, Email, Matrix, Feishu — you have hit this: an in-flight conversation drops because the gateway lost its connection for forty seconds during a deploy.

Auto-resume keeps the conversation alive across short outages. When the gateway reconnects, Hermes:

1. Replays any missed inbound messages.
2. Re-sends any outbound messages that did not get an ack.
3. Restores the in-flight conversation state from durable storage.

You do not need to do anything to use this. It is on by default.

Post-Write Linting

A small, satisfying change. When Hermes writes a file, it now runs the project's declared linters on the result and reports any new errors back to itself. If the lint failure is in code Hermes just wrote, it gets a chance to fix it before declaring the task done.

You configure this with the project-level Hermes config:

post_write:
  lint:
    - tool: eslint
      pattern: "**/*.ts"
    - tool: ruff
      pattern: "**/*.py"
    - tool: shellcheck
      pattern: "**/*.sh"

This catches the "wrote three lines of broken syntax and called it done" failure mode that the rest of the agent industry is still chasing.

Eight P0 Security Fixes

The release notes call out eight P0 (top severity) security fixes. The Hermes team has not published full CVE details, but the categories include path traversal in the file tools, injection in the gateway adapters, and credential leak in error reporting. Upgrade promptly.

If you are on a managed Hermes deployment (Agent37 or similar), the upgrade has already happened. If you self-host, the command is:

pip install -U hermes-agent
systemctl restart hermes-agent

Upgrade Notes

• Back up your Hermes data directory first. Kanban and checkpoint storage land in ~/.hermes/state by default; back this up before upgrading.
• Review your gateway configs. Auto-resume is on by default, but very old gateway configs may need a regenerate step (hermes gateway repair).
• Audit your /goal use. The new persistence means a goal you set in March is still active in May unless you cleared it. Run /goal show after upgrade.

Bringing It Back Together

"Tenacity" is the right word. Each of the headline features is about Hermes refusing to drop something it was working on. Persistent goals, durable Kanban, recoverable checkpoints, resumable gateways, self-correcting writes. The agent that forgets less is the agent you can actually delegate to.

For where this sits in the broader 2026 landscape, see OpenClaw vs Hermes Agent and the three-runtime comparison.

Sources

• Hermes Agent GitHub — https://github.com/nousresearch/hermes-agent
• Hermes Agent v2026.5.7 release notes — https://github.com/NousResearch/hermes-agent/releases/tag/v2026.5.7
• Hermes documentation — https://hermes-agent.nousresearch.com/docs/
• Nous Research — https://nousresearch.com/
• Related: What Is Hermes Agent
• Related: Hermes Checkpoints v2 and /rollback
• Related: Hermes Voice Mode