Set the target. Walk away.
Hermes /goal gives the agent a standing objective that survives every turn. A judge model decides "done or continue" after each response. If the goal isn't met, Hermes feeds itself the next prompt and keeps working — until the target is hit or the turn budget runs out. Close your laptop. Come back to finished work.
"Set the target. Walk away. Hand Hermes a long-horizon goal. It runs hermes chat --yolo --max-turns 50 in its own scratch dir. Close your laptop, go to sleep, come back to finished work."
What Hermes Goal Mode actually is
/goal gives Hermes a standing objective that doesn't die at the end of a single turn. After every turn, a lightweight judge model reads the agent's last response and decides: done or continue. If continue, Hermes auto-feeds a continuation prompt back into the same session and keeps working — without you typing "keep going" three more times.
It's Nous Research's take on the Ralph loop — keep a goal alive, don't stop until it's achieved. Directly inspired by Codex CLI 0.128.0's /goal by Eric Traut at OpenAI, but adapted to Hermes' architecture: central command registry, SessionDB-backed persistence, auxiliary-client judge model, adapter-FIFO continuation on the gateway side.
Works identically on the CLI and every gateway: Telegram, Discord, Slack, Matrix, Signal, WhatsApp, SMS, iMessage, Webhook, API, and the Mission Control web dashboard.
The old way vs the new way
Same long-horizon task. Same agent. Two completely different workflows.
- You type the goal. Agent does one turn. Stops.
- You type "keep going." Agent does one more turn. Stops.
- You type "keep going." Repeat 10–20 times.
- Each prompt loses some context — agent forgets the original goal halfway
- If you walk away for an hour, the agent is sitting idle waiting for your next "keep going"
- Long refactors take hours of human-in-the-loop attention
- Goals get abandoned because nobody wants to babysit a chat
- One
/goal <text>. Agent starts immediately. - Judge model decides done/continue after every turn — no human needed
- 20-turn budget by default (configurable). Auto-pauses at the limit so you can resume in chunks
- Original goal text stays in context every turn — agent never forgets the target
- Persists across
/resume— close the laptop, come back tomorrow, goal still standing /subgoal <text>tightens success criteria mid-loop without breaking the run- You set the target. You walk away. You come back to finished work.
"You don't manage the agent turn by turn. You hand it the target."
The judge, the budget, the loop
Three moving parts power Goal Mode. Each one matters.
The judge
After every turn, Hermes calls an auxiliary judge model with:
- The standing goal text
- The agent's most recent final response (last ~4 KB)
- A system prompt asking for strict JSON:
{"done": <bool>, "reason": "<one-sentence rationale>"}
The judge is deliberately conservative — it only marks a goal done when the response explicitly confirms completion, when the deliverable is clearly produced, or when the goal is genuinely blocked (treated as done with a block reason so the budget isn't burned on impossible tasks). Fail-open semantics: if the judge errors, Hermes treats the verdict as continue. A broken judge never wedges progress.
The turn budget
Default is 20 continuation turns (goals.max_turns in ~/.hermes/config.yaml). When the budget hits, Hermes auto-pauses and tells you exactly how to proceed:
/goal resume resets the counter to zero so you can run in measured chunks. Raise the budget for long refactors. Lower it for tighter loops.
The loop
The continuation prompt is a plain user-role message appended to history. It doesn't mutate the system prompt, swap toolsets, or invalidate the prompt cache. Running a 20-turn goal costs the same cache-wise as 20 turns of normal conversation. User messages always preempt the loop — anything you send takes priority over the queued continuation, and the judge runs again after your message.
Every command, on one screen
| Command | What it does |
|---|---|
/goal <text> | Set (or replace) the standing goal. Kicks off the first turn immediately — no separate message needed. |
/goal or /goal status | Show current goal, its status, and turns used. |
/goal pause | Stop the auto-continuation loop without clearing the goal. |
/goal resume | Resume the loop — resets the turn counter to zero. |
/goal clear | Drop the goal entirely. |
/subgoal <text> | Append a new acceptance criterion to the active goal. Tightens success criteria without breaking the loop. |
/subgoal | Show the current numbered subgoal list. |
/subgoal remove <N> | Remove the Nth subgoal (1-based). |
/subgoal clear | Drop every subgoal but keep the original goal intact. |
The /subgoal command is the one most operators miss. You start with "fix the failing tests" and partway through realise you also want "add a regression test for the bug you just patched." /subgoal add a regression test appends the criterion to the goal, and the judge now requires both before marking done. Tighten success criteria without restarting the loop.
One goal in. Many turns out.
— this is the playThe four-file example
Here's the canonical example, lifted from the Hermes docs. Watch what one /goal invocation triggers.
⊙ Goal set (20-turn budget): Create four files /tmp/note_{1..4}.txt, one per turn, each containing its number as text
Hermes: Creating /tmp/note_1.txt now.
💻 echo "1" > /tmp/note_1.txt (0.1s)
I've created /tmp/note_1.txt with the content "1". I'll continue with the remaining files on the next turn as you specified.
↻ Continuing toward goal (1/20): Only 1 of 4 files has been created; 3 files remain.
Hermes: [Continuing toward your standing goal]
💻 echo "2" > /tmp/note_2.txt (0.1s)
Created /tmp/note_2.txt. Two more to go.
↻ Continuing toward goal (2/20): 2 of 4 files created; 2 remain.
Hermes: [Continuing toward your standing goal]
💻 echo "3" > /tmp/note_3.txt (0.1s)
↻ Continuing toward goal (3/20): 3 of 4 files created; 1 remains.
Hermes: [Continuing toward your standing goal]
💻 echo "4" > /tmp/note_4.txt (0.1s)
All four files have been created: /tmp/note_1.txt through /tmp/note_4.txt, each containing its number.
✓ Goal achieved: All four files were created with the specified content, completing the goal.
You: _
Four turns. One /goal invocation. Zero "keep going" prompts. The judge caught completion on turn 4 and stopped the loop automatically.
What this actually unlocks
Two real goals I ran this week, both inside Mission Control:
🏆 Goal 1 — "Build out a beautiful SEO website about OpenClaw"
Hermes spawned a goal in its own scratch dir. 3 minutes 18 seconds later, exit code 0. It built a complete Next.js SEO site — custom landing page (12.8 KB), blog index, comparison page (3.7 KB), features page (3.9 KB), full SEO metadata (OpenGraph, Twitter cards, keywords), custom styling. Plus a real comparison post: "OpenClaw vs Hermes: The 2026 Showdown — We ran both on identical hardware. The results surprised us."
I did not touch the keyboard once during those 3 minutes. The agent fired turn 1, the judge said "continue, the site needs more pages," Hermes added them, judge said "continue, no blog content yet," Hermes drafted it, judge eventually said "done, site is structurally complete and ready to deploy." Closed.
🏆 Goal 2 — "Write a one-line haiku about a golden lobster"
Hermes: 💻 echo "Golden claws shimmer, ocean's armored sunlit king, silent waves whisper." > lobster-haiku.txt
✓ Goal achieved · exit 0
One turn. One file. Done. The judge correctly identified completion without an unnecessary continuation.
"Hermes ran autonomously, wrote a haiku, saved it to disk, marked itself completed. I was making coffee."
Hermes Goal Mode + the full Agent OS
Goal Mode is one tab inside Mission Control — Chat, Goal Mode, Workspace, Control Room. Plus Hermes sits next to Claude, OpenClaw, Codex, Antigravity, Gemini, Free Claude Code in the wider sidebar. Inside AIPB: the full install, the prompts, the SOPs, the 30-day roadmap, weekly coaching calls.
Get Agent OS in AIPB →Goals survive the laptop closing
Goal state lives in SessionDB.state_meta keyed by goal:<session_id>. Close your laptop, come back tomorrow, run /resume — the goal is standing exactly where you left it (active, paused, or done).
And inside Mission Control there's a stronger safety net. Every goal runs in its own scratch dir under ~/.hermes/goals/<id>/ with a full log of every stdout chunk. If anything goes wrong with the state file (race conditions, server crash, manual file edit), Mission Control's orphan recovery scans the scratch directory on every list-goals call and re-creates entries automatically — with the original prompt pulled from the log.
I lost the entry for the SEO site goal once during testing. The dashboard showed nothing. The site was sitting at ~/.hermes/goals/hg_mpkmd3xn_y9wy/ — 24 files, exit code 0, fully working. Orphan recovery brought it back on the next page load with the original prompt intact.
When the judge gets it wrong
No judge is perfect. Two failure modes to watch for:
- False negative — judge says continue when the goal is actually done. The turn budget catches this. You'll see
⏸ Goal pausedat 20/20 and can/goal clearor send a new message. - False positive — judge says done when work remains. You'll see
✓ Goal achievedbut you know better. Send a follow-up to continue, or re-set the goal more precisely with/goal <more specific text>.
The judge's system prompt is deliberately conservative to make false positives rarer than false negatives. If you find a verdict unconvincing, the reason text in the ↻ Continuing or ✓ Goal achieved line tells you exactly what the judge saw — usually enough to diagnose whether the goal text was ambiguous or the response was.
Pro tip: route the judge to a cheap fast model to keep costs down. Add to ~/.hermes/config.yaml:
goal_judge:
provider: openrouter
model: google/gemini-3-flash-preview
The judge call is small (~200 output tokens) and runs once per turn. A cheap fast model is usually the right call.
Three beliefs holding you back
The setup is free. The agent is open-source. The blockers are mental.
Want proof other operators run hands-off goals? Read 258 unfiltered member wins from the AI Profit Boardroom →
"Hands-off agents are dangerous — I want to watch every step."
Every goal runs in its own scratch dir under ~/.hermes/goals/<id>/. Nothing collides with your real work. The full log streams live. You can /goal pause or /goal clear at any moment. Hands-off doesn't mean trustless — it means scoped.
"The judge model will always get it wrong on hard goals."
It gets it wrong sometimes. The 20-turn budget is the backstop — false negatives auto-pause at the limit. False positives are rare because the judge is deliberately conservative. And when it errors, fail-open semantics treat the verdict as continue, so a broken judge never wedges your work.
"I'll just keep typing 'keep going' — same result."
Same agent. Different bottleneck. With "keep going" you're the bottleneck on every turn — agent waits for you. With /goal you set the target, walk away, and come back to finished work. Long refactors that took your whole afternoon take 20 minutes of agent wall-clock without you in the loop.
30-day roadmap
hermes, then /goal create four files /tmp/note_1.txt through /tmp/note_4.txt, each containing its number. Watch the loop work. Confirm ✓ Goal achieved. Done./goal every morning for a week. See it become a habit./subgoal mid-run. Launch a multi-criterion goal ("fix every lint error and verify ruff check passes"). Mid-run, add /subgoal also add a test for the bug you just patched. Watch the judge enforce both before marking done.goal_judge override in ~/.hermes/config.yaml to route judge calls to Gemini 3 Flash or a free OpenRouter model. Lower cost per goal by ~80%./goal port feature X from repo Y, including tests, and get CI green — and close your laptop. Come back tomorrow to a completed PR or a paused goal you can /resume.Hermes Goal Mode — recap
Three moving parts: the judge model (decides done/continue after every turn), the turn budget (default 20, auto-pauses at the limit, /goal resume resets), and the continuation loop (plain user-role message appended to history — cache-friendly, never wedges).
The result: long-horizon work that finishes on its own. You stop being the bottleneck on tasks bigger than one turn. Set the target. Walk away. Come back to finished work.
Set the target. Walk away. Free.
Inside AIPB: the full Hermes install, Goal Mode configuration, the cheap-judge override, the prompt library for long-horizon tasks, the 30-day roadmap, weekly coaching calls, and the rest of Agent OS — Claude, OpenClaw, Codex, Antigravity, Gemini, Free Claude Code — wired together in one Mission Control.
Join the AI Profit Boardroom →