Hermes Checkpoints v2 and /rollback: Time Travel for Long-Running Agents

The single most under-appreciated change in Hermes Agent v0.13.0 is Checkpoints v2. It does not show up as a new feature on the marketing page. It is not where the announcement cycle put its energy. But if you actually delegate work to a long-running agent, this is the change that adjusts how much you can hand off.

The shape of the change: Hermes now takes structured snapshots of its own state at every meaningful inflection point. You can return to any of them with /rollback. The agent's autonomy becomes bounded by the worst possible commit, not the worst possible session.

Key Takeaways

• Checkpoints v2 is a structured snapshot of agent state at a point in time, not a single tar of the working dir.
• A checkpoint captures: workdir diff, Kanban state, goal state, memory index pointer, and the tail of tool history.
• Checkpoints fire automatically before destructive actions and on explicit /checkpoint.
• /rollback returns the agent to the most recent checkpoint, or a named one, in one command.
• Compared to git reset, a checkpoint covers more than the filesystem — Kanban cards, in-flight goal state, and memory pointers also roll back.
• Compared to a chat undo, a checkpoint commits to a known-good state, not just the last user input.

Why "Just Use Git" Is Not Enough

If you spend your day in code, the obvious objection is "I have git, I have IDE undo, why do I need checkpoints?"

The answer is that agent state is not just the filesystem. When Hermes runs for hours, the things that change include:

• The working directory (yes, git covers this).
• Kanban cards moving through states.
• The active goal and its sub-decomposition.
• Memory entries written and indexed.
• Outbound messages sent on messaging gateways.
• Side-effects through tools (PRs opened, files uploaded, emails sent).

Git rolls back one of these. Checkpoints v2 rolls back four. The remaining two — outbound messages and external side-effects — are explicitly out of scope and require compensating actions. A checkpoint records that they happened so the agent knows what it cannot undo.

What a Checkpoint Actually Contains

checkpoint:
  id: ck_2026_05_08_3f
  taken_at: "2026-05-08T09:14:22Z"
  trigger: pre_destructive_action
  reason: "About to run migration 042_drop_legacy_users"
  contents:
    workdir_diff:
      base: ck_2026_05_08_2b
      patch: <diff>
    kanban_state:
      cards: 14
      hash: 7c2e4d…
    goal_state:
      active: "Ship better-auth migration"
      progress: 0.62
    memory_index:
      head: mem_2026_05_08_a1
    tool_history_tail:
      last_n: 50
      hash: 9bd13f…
    external_actions:
      since_last_checkpoint:
        - { kind: "github.pr.opened", id: "1234" }
        - { kind: "slack.message.sent", to: "#eng" }

The structure matters. /rollback can reverse the things in contents (modulo external_actions) deterministically. It cannot reverse the GitHub PR — but it knows to surface a "we still have an open PR from a rolled-back branch; do you want to close it?" prompt.

Automatic Triggers

You do not have to remember to checkpoint. Hermes triggers a snapshot automatically when:

• It is about to call a high-risk tool capability (deletes, force-pushes, destructive migrations, mass-edits).
• A goal's progress threshold passes a milestone.
• A Kanban card transitions to done.
• A gateway-driven conversation hits a configurable turn boundary.
• A long-running tool call (over a configurable wall-clock threshold) begins.

You can also /checkpoint "label" manually before doing anything you are nervous about.

/rollback Mechanics

/rollback accepts a checkpoint id, a label, or no argument (returns to the most recent):

> /rollback
Rolling back to ck_2026_05_08_3f (pre_destructive_action, 14 minutes ago).
  ✓ Restored 7 modified files
  ✓ Restored kanban state (14 cards)
  ✓ Restored goal state
  ✓ Restored memory index head
  ⚠ External actions since checkpoint:
      - github.pr.opened #1234 (still open)
      - slack.message.sent to #eng (cannot retract)
    Run /rollback-actions to compensate, or /accept-external to keep as-is.

The agent does not silently rewind things that have left the building. It tells you about them and asks for a decision. This is the legibility that turns rollback from a footgun into a tool.

When Checkpoints Earn Their Keep

Three situations where Checkpoints v2 changes what you are willing to delegate:

1. Risky migrations. Asking an agent to "run the auth migration end-to-end" is much easier when you know there is a snapshot of "before we touched anything."
2. Speculative refactors. You can let Hermes try a refactor on a long-running goal, see if it converges, and rewind if it does not — without manually reverting commits or untangling Kanban state.
3. Multi-agent handoffs. When passing a Kanban card from Hermes to Claude Code as a subagent, the parent agent can checkpoint, hand off, and rewind cleanly if the subagent's output is wrong.

How It Compares to OpenClaw TaskFlow Recovery

OpenClaw's TaskFlow orchestration gives a different flavor of rewind. TaskFlow recovers a flow — a structured business process with declared steps. Hermes Checkpoints v2 snapshots an agent's state — much more general, less structured.

Use both if you run both. Use whichever your work fits.

Practical Tips

• Pin a checkpoint before any week-long goal. /checkpoint baseline-2026-w19 gives you a named rollback target for the whole project.
• Wire compensating actions for your external systems. If Hermes opens PRs, add a pr.close capability so /rollback-actions can clean up.
• Don't disable automatic triggers. They look chatty in the logs and feel paranoid in practice. The day you need one, you really need one.

Bringing It Back Together

Autonomy is not the same as recklessness. The agent that can rewind is the agent that can take bigger steps, because the cost of being wrong is bounded. Checkpoints v2 is Hermes saying "here is the floor of how bad a bad branch can be." Once you have that floor, the ceiling of what you delegate goes up.

For the broader May release context, read Hermes Agent v0.13.0 'The Tenacity Release'. For the comparison with other 2026 runtimes, see OpenClaw vs Hermes Agent.

Sources

• Hermes Agent GitHub — https://github.com/nousresearch/hermes-agent
• Hermes Agent v2026.5.7 release — https://github.com/NousResearch/hermes-agent/releases/tag/v2026.5.7
• Hermes documentation — https://hermes-agent.nousresearch.com/docs/
• Related: Hermes Agent v0.13.0 Tenacity Release
• Related: OpenClaw TaskFlow Orchestration
• Related: Spawning Claude Code as a Hermes Subagent