---
title: Hermes /goal — The Full Guide
summary: >-
  A complete guide to Hermes' /goal command — what it does, every subcommand,
  how to write strong measurable goals, the recommended workflow, best
  practices, and ready-to-use example prompts.
author: YanXbt
authorUrl: 'https://x.com/IBuzovskyi'
category: Automation
difficulty: Beginner
readingTime: 5
date: '2026-06-17'
tags:
  - goal
  - autonomous-agent
  - workflow
  - subgoal
  - handoff
  - automation
integrations:
  - Hermes Agent
  - /goal
  - Telegram
  - Discord
---

## What /goal is and why it matters

`/goal` is one of the most powerful features introduced in Hermes v0.14 (Foundation Release). Unlike normal chat interactions where you give a task and get an immediate response, `/goal` turns Hermes into an **autonomous agent**.

You set a long-term objective, and Hermes breaks it down into smaller tasks, uses tools, writes and runs code, iterates, and keeps working until the goal is completed — or until you stop it.

In short, it transforms Hermes from a reactive chatbot into a **background worker** that can handle complex, multi-step tasks with minimal supervision.

## Main commands

These are the key commands you'll use to drive an autonomous goal:

| Command | Function | When to use |
| --- | --- | --- |
| `/goal <description>` | Starts working on a long-term goal | The main command to begin |
| `/goal` or `/goal status` | Shows current progress | Check how the task is going |
| `/goal pause` | Pauses the current goal | Temporarily stop execution |
| `/goal resume` | Resumes a paused goal | Continue after pausing |
| `/goal clear` | Clears the current goal | Start fresh |
| `/subgoal <text>` | Adds extra conditions or sub-objectives | Refine requirements during execution |
| `/handoff <platform>` | Transfers the session to Telegram, Discord, etc. | Continue work in another app |

## How to write strong goals

This is the most important part. The quality of your results depends heavily on how well you define the goal.

**Good goals are:**

- Specific and measurable
- Backed by clear success criteria
- Well-scoped — not too broad

**Examples of strong goals:**

- "Create a fully functional Flappy Bird clone in HTML5 with physics, keyboard and mouse controls, scoring system, and collision detection. The game must run on localhost and all core mechanics must work."
- "Build a clean multi-page website with a homepage, features, and pricing. Make it responsive and pass basic Lighthouse checks."
- "Refactor the main processing module, improve performance by 30%, add proper error handling, and ensure all tests pass."

**Weak goals (avoid these):**

- "Make something cool"
- "Improve my code"
- "Work on the project"

> **Rule:** The more clearly you describe the final outcome and how to verify it, the better Hermes will perform.

## Recommended workflow

1. **Provide context first.** Give Hermes information about your project, tech stack, folder structure, and previous decisions.
2. **(Optional) Generate good goals.** Use this meta-prompt:
   > "Based on what you know about me and my projects, suggest 3 strong `/goal` ideas that would run for a long time and create the most value."
3. **Launch the goal.** Write `/goal` followed by a detailed description.
4. **Manage the process.**
   - Use `/goal status` to check progress
   - Add `/subgoal` if you need to adjust direction
   - Pause or resume when needed
5. **Review the result.** Hermes returns completed work, a summary, or an explanation if the goal couldn't be fully achieved.

## Best practices and common mistakes

**Best practices:**

- Always make goals measurable with clear success criteria
- Use `/subgoal` actively to steer the agent
- Increase `max_turns` for long-running tasks:

```bash
hermes config set goals.max_turns 500
```

- Combine Hermes with Codex or Claude Code for better results
- Run complex goals overnight

**Common mistakes:**

- Using vague goals without success criteria
- Intervening too often instead of letting the agent work
- Starting without enough project context
- Making goals too broad or open-ended

## When to use /goal

**Good for:**

- Complex, multi-step tasks (building apps, refactoring, research)
- Work that benefits from iteration and self-correction
- Tasks you can leave running for hours
- Situations where you want to delegate rather than micromanage

**Not ideal for:**

- Simple or quick tasks
- Situations where you need full control over every step
- When you haven't clearly defined the desired outcome yet

## Example /goal prompts

Practical examples of well-written goals:

**Example 1 — Game**

```text
/goal Create a fully functional Flappy Bird clone in HTML5. Include physics,
keyboard and mouse controls, scoring system, and collision detection. The game
must run on localhost and all core mechanics must work without bugs.
```

**Example 2 — Web Project**

```text
/goal Build a clean multi-page website for a productivity tool. Include homepage,
features page, and pricing section. Use modern design, responsive layout, and
smooth animations. All pages must pass basic Lighthouse checks.
```

**Example 3 — Code Refactoring**

```text
/goal Refactor the main processing module in my repository. Improve performance
by at least 30%, add proper error handling, write unit tests for all functions,
and ensure all existing tests still pass.
```

**Example 4 — Research**

```text
/goal Research 5 competitors in the AI productivity space. Create a structured
comparison table with pricing, key features, strengths and weaknesses. Save the
final report as a markdown file.
```

> **Tip:** Start with a clear end result plus verifiable criteria. You can always add more details later using `/subgoal`.