Hermes Agent Goals, Background Tasks & Kanban Guide

Hermes Agent goals, background tasks, and kanban — a practical guide

"Hermes agent dreaming" is one of the more searched-for phrases about Hermes right now. But there's no /dreaming command. There's no dreaming mode you can toggle on. What people are describing when they say Hermes is "dreaming" is something real, though. They're watching the agent do work without being asked.

It curates its own skill library overnight. It loops through a research task for twenty turns while you make dinner. It runs a background job and drops the result in your terminal when it's done. It dispatches tasks across a team of agents on a shared board.

These are four distinct features, shipped across Hermes v0.12 and v0.13 in April and May 2026. Here's how each one works and when to use it.

The Curator: Hermes maintains its own skills

Every time Hermes completes a task, it can write a skill file to ~/.hermes/skills/. Over weeks of use, that folder accumulates dozens of skills, some good, some redundant. The Curator exists to clean house.

It runs as a background agent on the gateway's cron ticker, defaulting to a 7-day cycle. It grades each skill in your library, consolidates related ones, and prunes the dead ones. Every run writes a report to ~/.hermes/logs/curator/ with both a machine-readable run.json and a human-readable REPORT.md.

You can check what's getting stale with hermes curator status, which lists your five least-recently-used skills.

This is probably the closest thing Hermes has to "dreaming" in the way most people mean it. The agent reflects on what it's learned, decides what's still useful, and tidies up. You don't have to watch it do this. It just happens.

Bundled and hub-installed skills are protected. The Curator can't modify or delete anything that didn't originate from the agent's own learning. So your hand-written skills and anything you installed deliberately are safe.

Persistent goals: autonomous iteration on one task

The /goal command gives Hermes a standing objective that survives across turns. After every turn, a judge model reads the assistant's last response and decides whether the goal is met. If not, Hermes feeds a continuation prompt back into the session and keeps going.

You'll see output like ↻ Continuing toward goal (3/20): still needs the error handling section as it loops. It stops when one of three things happens: the goal is satisfied, you pause or clear it, or it hits the turn budget (default 20, configurable via goals.max_turns in ~/.hermes/config.yaml).

The judge is deliberately conservative. It only marks done when the response explicitly confirms completion. If the judge itself errors, Hermes treats the verdict as "continue." A broken judge never stalls the work.

The commands: /goal <text> to set one, /goal status to check progress, /goal pause and /goal resume to control the loop, /goal clear to drop it. /goal resume resets the turn counter back to zero, so you can run in measured chunks.

Here's a real example from last week. I set a goal to research 30 dated kids' events near London for the next three months, pulling from seven specific sites I'd listed (Day Out With The Kids, Eventbrite, Happity, and a few others). The agent started scraping immediately, looping through execute_code calls, and hit 30 results within about five minutes.

The problem: it had ignored my source list entirely and pulled everything from Skiddle, because Skiddle exposes clean JSON-LD and the sites I actually wanted are JavaScript-heavy with bot protection. I told it to drop Skiddle and use my sources. It tried, discovered its Apify token wasn't loaded in the subprocess environment (even though it was set up and had worked before), fell back to static HTTP extraction, got blocked by Cloudflare on Happity, and returned half-empty results from the rest.

I pushed back again. It eventually found the token, identified API endpoints on Club Hub, and started making real progress. But the whole thing took about four hours of me checking in every 30-60 minutes, redirecting, and telling it to keep going. The goal didn't auto-complete. It kept iterating, which was the point, but it needed steering.

That's the honest version of how /goal works in practice. It's not "set and forget." It's more like a junior colleague grinding through a task while you check in periodically. The agent does the volume work. You provide the judgment calls.

Background tasks: parallel work in isolation

/background (or /bg) spawns a completely separate agent session in a daemon thread. It gets its own conversation history but inherits your model, provider, toolsets, and reasoning settings from the current session.

Your foreground session stays fully interactive. You can keep chatting, run other commands, or start more background tasks. Each one gets a numbered ID. When a task finishes, the result appears as a panel in your terminal.

This is different from /goal in an important way. Goals iterate within the same session, refining one thing in front of you. Background tasks run in isolation. Use goals when you want Hermes to keep working on something you'll review. Use background when you want parallel work that doesn't clutter your current conversation.

Kanban: a task board for multiple agents

This is the feature that makes Hermes feel like a different category of tool. Kanban gives you a durable task board, backed by SQLite (~/.hermes/kanban.db), shared across all your Hermes profiles. Multiple agents claim tasks, work in parallel, and hand off when blocked.

Initialise with hermes kanban init. Open the dashboard with hermes dashboard (runs at http://127.0.0.1:9119). Create tasks with hermes kanban create "your task description" --assignee profile-name.

The dispatcher (hermes kanban dispatch) scans for dispatchable tasks and spawns workers. Each worker is a full OS process with its own identity. Agents interact with the board through dedicated tools: kanban_show, kanban_complete, kanban_block, kanban_heartbeat, kanban_comment, kanban_create, kanban_link. The dispatcher injects these into each worker's tool schema automatically.

Fifteen verbs work both from the CLI (hermes kanban <verb>) and as slash commands (/kanban <verb>): init, create, list, show, assign, link, unlink, claim, comment, complete, block, unblock, archive, tail, dispatch.

The reliability layer is what makes this more than a toy. Heartbeat monitoring tracks whether agents are actually alive. Zombie detection catches stuck tasks. Auto-block fires on incomplete exits. Per-task retry budgets let individual tasks fail and recover. A hallucination gate catches invalid outputs before they corrupt the board.

This is the feature I'd want to understand before deciding whether Hermes is worth running on a team. One agent doing your inbox is nice. Five agents working a board while you sleep is a different proposition.

I haven't started using Kanban yet, but it's high on my list. The use case I have in mind: managing a queue of issues on a web app, where agents triage and work through them and I review the results. That's the kind of workflow where a shared board makes more sense than me dispatching tasks one by one.

The Claude connection

If "dreaming" sounds familiar from another context, Anthropic shipped a feature literally called "dreaming" for Claude on May 6. Claude's version is a scheduled background process that reviews past agent sessions, prunes stale memories, and consolidates insights. It solves the same problem as Hermes's Curator but for memories rather than skills.

Both tools independently arrived at the same idea: agents that maintain themselves between sessions. I'll write a separate post on Claude's dreaming feature once I've had more time with it.

Where to start

If you haven't installed Hermes yet, start with the Hostinger VPS setup guide. Once it's running, read the tips post for the configuration and model selection stuff that saves you a weekend.

If you're deciding between agent frameworks, the OpenClaw vs Hermes vs Cowork comparison covers the trade-offs.

And if you'd rather have someone set this up with you in person, that's what I do. Book a session and we'll get your agent stack running in 90 minutes.