Hermes CLI in practice: configuration, TUI, queue, steer, and skills Link to heading
So far, we have looked at Hermes Agent as architecture, memory, and profiles. Now comes the part that changes day-to-day use: the CLI.
And it is worth clearing one distraction right away: using the terminal only to ask a one-off question to the model is the least interesting use of Hermes. There is a command for that, of course. But what really matters is configuring the agent well and knowing how to control the session while it is alive.
The Hermes CLI is more useful as an operational panel. It configures provider, model, authentication, memory, toolsets, skills, sessions, gateway, and integrations. Inside the TUI, it also gives you commands to switch model, load a skill, queue an instruction, steer an execution in progress, and inspect the agent state.
This article is that practical map: which basic commands are worth remembering, which ones live in the TUI, and which flow to use after installation.
Before You Continue: What You Should Already Have Link to heading
This article assumes you already went through the installation tutorial, opened Ubuntu/WSL, installed Hermes, and validated the basic command:
hermes --version
If you are on Windows and following the series from the beginning, run hermes ... commands inside Ubuntu/WSL, not in native PowerShell. PowerShell is still useful for managing Windows, but Hermes in this flow is installed inside the Linux environment.
It also helps if you have already logged in with your chosen provider, especially OpenAI Codex, and if hermes status does not show any obvious authentication error. If that has not happened yet, go back to the installation post before trying to memorize the TUI.
The First Use Without Getting Lost Link to heading
If you just want to start safely, you do not need to know every command in this article. Follow this route:
hermes doctor
hermes status
hermes model
hermes --tui
Inside the TUI, run:
/help
/status
/model
This path answers the first questions any new user has: whether the environment is healthy, whether Hermes is authenticated, which model is active, and which commands the current session accepts.
After that, test a simple question inside the TUI. Something like:
Explain in one sentence what you can do in this session.
If that first conversation works, then it makes sense to move on to skills, toolsets, queue, steer, memory, and longer sessions.
What Is Worth Remembering First Link to heading
In Hermes, there are three layers of commands.
First, configuration commands, which you run in the terminal to prepare the environment:
hermes setup
hermes auth
hermes model
hermes doctor
hermes status
Second, session commands, which open daily use:
hermes
hermes --tui
hermes --continue
hermes --resume <session_id>
Third, TUI slash commands, which you type inside the session:
/help
/status
/model
/tools
/skills
/queue
/steer
/busy status
This third layer is what changes the ergonomics. You stop treating the agent as one giant prompt and start conducting an execution.
Starting With hermes
Link to heading
The simplest command opens an interactive session:
hermes
This is the classic interactive mode. You type, Hermes responds, calls tools when needed, and saves the session.
Use it when:
- you want to work across several turns;
- you want to follow tool calls;
- you want to use slash commands;
- you want to refine a task over time;
- you want the agent to research, execute, and answer.
hermes --tui
Link to heading
Hermes also has a modern TUI:
hermes --tui
The documentation describes this interface as a richer terminal experience, with overlays, mouse support, and non-blocking input.
This tends to be the most interesting mode for daily use, because Hermes feels less like “prompt and response” and more like an operating bench.
Use it when:
- you want a more comfortable experience than the classic CLI;
- you want to follow longer sessions more easily;
- you prefer a modern terminal UI;
- you want to use visual navigation features.
Model, Provider, and Toolsets Link to heading
After installation, the first job is not to start asking questions. It is to check which model, provider, and tool set Hermes will use.
To configure the default model:
hermes model
To review credentials:
hermes auth
To review tools and toolsets:
hermes tools
A toolset is a group of tools. This matters for safety and focus. If the task does not need terminal access, do not give it terminal access. If it does not need web access, do not give it web access. The smaller the tool set, the lower the chance of accidental behavior.
Inside a session, the same idea reappears through slash commands:
/model
/tools
/toolsets
In other words: hermes model, hermes auth, and hermes tools prepare the house; /model, /tools, and /toolsets help you operate the session in progress.
Preloading Skills With -s
Link to heading
You can start Hermes with a skill:
hermes -s github-pr-workflow
Or open a session already guided by a specific skill:
hermes --tui -s github-pr-workflow
A skill is a procedural instruction loaded on demand. Think of it as a work recipe: when to use it, how to act, which steps to follow, which traps to avoid, and how to verify the result.
We will come back to skills in a moment.
Resuming Sessions: --continue and --resume
Link to heading
To continue the latest session:
hermes --continue
Shortcut:
hermes -c
To resume a specific session:
hermes --resume <session_id>
Shortcut:
hermes -r <session_id>
This is the basic continuity layer in Hermes. Beyond the session, memory, skills, and session search become additional layers. That is why resuming a conversation in Hermes is not just recovering old text; it is recovering an operational state.
Configuration and Base Commands Link to heading
The official reference lists several commands. The idea here is not to turn everything into a mandatory checklist. Read this section as a reference map: when you find a command in Hermes, come back here to remember where it fits.
For a beginner, the most important ones are hermes doctor, hermes status, hermes model, and hermes --tui. The other commands are for maintenance, integrations, profiles, gateway, memory, and automations.
Let us go through the practical map, starting with the commands that make the environment reliable before the first long session.
hermes model
Link to heading
Configures the default provider and model:
hermes model
This is the right command for choosing OpenAI Codex, Nous Portal, OpenRouter, Anthropic, and other configurable providers.
hermes setup
Link to heading
Opens the configuration assistant:
hermes setup
It can reconfigure areas such as model, terminal, gateway, tools, and agent. In an existing installation, quick mode asks only about missing items:
hermes setup --quick
Think of it as an environment assistant. To switch or add a provider/model, hermes model remains the most direct path.
hermes auth
Link to heading
Manages credentials:
hermes auth
It can add, list, remove, reset, or define authentication strategy. Current documentation recommends hermes auth; login and logout appear as legacy/deprecated paths.
hermes status
Link to heading
Shows agent, authentication, and platform status:
hermes status
Use it when you want to see the current state: Hermes project, active model, provider, auth providers, API keys, messaging platforms, gateway, jobs, and sessions.
hermes doctor
Link to heading
Diagnostics:
hermes doctor
This should be one of the first commands in troubleshooting. The practical difference is: status shows how Hermes is configured now; doctor looks for what is missing or likely to break.
hermes config
Link to heading
Inspects and adjusts configuration:
hermes config
Useful for understanding config.yaml, defaults, and migrations.
hermes skills
Link to heading
Manages skills:
hermes skills browse
hermes skills search react
hermes skills install openai/skills/k8s
hermes skills list
hermes skills audit
hermes skills update
This command is the door into Hermes’ procedural library.
Important: hermes skills by itself is a command group. To list what is already installed, use hermes skills list. To discover available skills, use hermes skills browse or hermes skills search <term>.
hermes curator
Link to heading
Controls Curator, the system that reviews skills:
hermes curator
Use it to review, archive, restore, or audit the accumulation of skills.
hermes memory
Link to heading
Configures an external memory provider:
hermes memory setup
hermes memory status
hermes memory off
Do not confuse this with manually editing MEMORY.md. The command is especially relevant for providers such as Honcho, Mem0, and OpenViking.
hermes sessions
Link to heading
Lists and manages sessions:
hermes sessions list
Use it to browse history and resume conversations.
hermes gateway
Link to heading
Manages the gateway:
hermes gateway setup
hermes gateway run
This command becomes important in the fifth article, because gateway involves security.
hermes tools
Link to heading
Configures tools and toolsets:
hermes tools
Use it to control what the agent can do.
hermes mcp
Link to heading
Manages MCP servers:
hermes mcp list
hermes mcp add my-server --command my-command
hermes mcp test my-server
hermes mcp configure my-server
MCP expands tools by connecting Hermes to external servers.
hermes acp
Link to heading
Starts Hermes as an ACP server:
hermes acp
This mode lets you use Hermes inside editors compatible with Agent Client Protocol.
hermes cron
Link to heading
Inspects and runs scheduled tasks:
hermes cron
In Hermes, cron is not just a shell script. It is an agent task, which can load skills and deliver responses through platforms.
hermes logs
Link to heading
View, filter, or follow logs:
hermes logs
Essential for gateway, cron, and long sessions.
hermes profile
Link to heading
Manages profiles:
hermes profile
Profiles isolate HERMES_HOME, configuration, memory, sessions, and gateway. This allows multiple agents on the same computer with different identities and configurations.
Because this changes Hermes’ operational architecture, the main explanation stayed in the previous article in the series. Here, the point is only to recognize the command: use hermes profile when you want to inspect, create, or switch profiles before entering the daily CLI flow.
hermes update
Link to heading
Updates Hermes:
hermes update
Use it after checking changelog and risks, especially in a production installation.
Slash Commands: Commands Inside the Conversation Link to heading
Now comes the more interesting part: commands you do not run in the system shell, but inside the conversation with Hermes itself.
They are called slash commands because they start with /. In practice, they work as special messages to the agent. Instead of asking “switch the model” in natural language, you type /model. Instead of explaining that you want to see available skills, you type /skills.
The most complete place to use these commands is the Hermes TUI. By default, slash commands are available there, because the TUI is the interface made for operating a live session: switching model, checking state, loading a skill, queueing an instruction, steering direction, and following tools.
But the idea is not limited to the terminal. When Hermes is connected to conversation channels, such as Telegram, Discord, Slack, or another supported app, some commands can also be sent through the chat itself. In those cases, they are still commands “inside the conversation”, except the conversation happens outside the TUI.
The important difference is that availability can vary by channel. In the TUI, expect to find the main command set. In app integrations, support depends on the channel, gateway configuration, permissions, and the way that connector interprets command messages.
/help
/model
/queue
/steer
/skills
Think of these commands as operational controls. They change state, control execution, load skills, or show information without forcing everything into a long prompt.
/help
Link to heading
The basic one:
/help
Shows available commands. It sounds trivial, but in a rich CLI it is the living map. Use it whenever you are unsure before memorizing a command.
/status
Link to heading
Shows session state:
/status
Useful for confirming provider, model, session, and context.
/model
Link to heading
Switches model inside the conversation:
/model
Important: /model switches among already configured options. To configure a new provider, use hermes model outside the session.
/personality
Link to heading
Controls personality in the session:
/personality
This connects to the identity layer. Use it to adjust behavior without turning every prompt into a long instruction letter.
/tools and /toolsets
Link to heading
Inspect or adjust tools:
/tools
/toolsets
These are critical safety commands. Too many tools increase risk and distraction.
/skills
Link to heading
Lists, installs, or loads skills:
/skills
/skills search docker
/skills install openai/skills/k8s
An installed skill can also appear as its own slash command:
/github-pr-workflow review this PR
/queue: Prepare the Next Message
Link to heading
/queue is one of the most interesting commands.
It lets you place the next message in the queue without interrupting what the agent is doing now.
Example:
/queue when you finish, generate a checklist of changed files
Use it when:
- the agent is executing a task;
- you already know the next step;
- you do not want to interrupt the current execution;
- you want to chain work.
Think of it as “when you are done, do this”.
/steer: Change Direction Mid-Execution
Link to heading
/steer injects guidance during an execution in progress.
Example:
/steer keep the current tests, do not rewrite the whole suite
This command is different from /queue. The queue waits for the current turn to finish. Steer guides the current work, usually after the next tool call.
Use it when:
- the agent is going in a risky direction;
- you want to correct scope;
- you want to add a constraint without aborting;
- you want to avoid rework.
It is like putting a hand on the steering wheel without turning off the engine.
Busy Modes: /busy queue, /busy steer, /busy interrupt
Link to heading
Hermes lets you define how input behaves while the agent is busy.
/busy queue
/busy steer
/busy interrupt
/busy status
The modes are:
queue: new messages enter the queue;steer: new messages become mid-run guidance;interrupt: Enter interrupts the agent;status: shows the current mode.
This changes the ergonomics quite a bit.
If you are supervising a long task, /busy steer may be better. If you are stacking tasks, /busy queue. If you want strict manual control, /busy interrupt.
/background
Link to heading
/background lets you run another session in parallel.
/background research alternatives for this bug while I continue here
Use it for independent tasks. Do not use it for two tasks editing the same files without coordination, because the risk of conflict increases.
/goal
Link to heading
/goal creates a persistent objective with auto-continuation.
/goal investigate the build failure and propose the smallest fix
It is useful when a task needs several steps and you want the agent to continue until it finishes or hits a limit.
/compress
Link to heading
Compacts context:
/compress
Use it when the conversation has become long and you want to preserve the essentials. Compression is a harness operation: it decides what stays in context and what becomes summary.
/rollback
Link to heading
Returns to a previous checkpoint:
/rollback
In agents that edit files, rollback is not luxury. It is a seat belt. Use it when the agent went in a bad direction and you want to restore an earlier point.
/curator
Link to heading
Opens Curator-related commands:
/curator
Curator is the system that reviews skills, detects obsolescence, can archive, restore, and keep the procedural library healthy.
What Is a Skill, After All? Link to heading
A skill is procedural memory.
Ordinary memory says:
This project uses Hugo.
A skill says:
When publishing a Hugo post in this project, follow these steps, validate these commands, watch for these errors, and deliver this report.
In Hermes, skills mainly live in:
~/.hermes/skills/
Each skill has a SKILL.md with front matter and instructions. It can have auxiliary files:
~/.hermes/skills/
devops/
deploy-k8s/
SKILL.md
references/
templates/
scripts/
assets/
Progressive Disclosure Link to heading
Skills follow a progressive loading pattern.
The agent first sees a summarized list of skills. It only loads the full content when needed. And it only opens specific auxiliary files when necessary.
This saves tokens and reduces noise. A library with hundreds of skills would be useless if all of them were shoved into the prompt every time.
Example SKILL.md
Link to heading
A minimal SKILL.md may look like this:
---
name: review-hugo-pr
description: Review a Hugo post PR focusing on front matter, references, and build.
version: 1.0.0
metadata:
hermes:
tags: [hugo, blog, review]
category: editorial
requires_toolsets: [terminal]
---
# Review Hugo PR
## When to Use
Use when the user asks for a blog post or PR review.
## Procedure
1. Read the post and the front matter.
2. Check slug, draft, tags, and references.
3. Run local validations.
4. List issues by severity.
## Verification
Confirm `hugo -D --templateMetrics` and `npm run build:dev`.
That is a reusable recipe.
Auto-Generated Skills Link to heading
Hermes can create skills after successful complex tasks. The documentation describes cases such as:
- a task with several tool calls;
- an error or dead end that was solved;
- explicit user correction;
- discovery of a non-trivial workflow.
That is Hermes’ self-learning thesis: turn experience into procedure.
But it is worth repeating: self-learning without curation becomes clutter.
Curator: the Skill Janitor Link to heading
Curator exists to review the skill library. It can identify old, redundant, broken, or low-value skills.
In a tool that creates skills, this is essential. Otherwise, the agent accumulates old instructions and starts tripping over its own history.
Think of Curator as maintenance for procedural knowledge.
Practical Flow: First Configuration Link to heading
If you just installed Hermes or are reviewing a new machine, do not start with the session. Start with diagnostics.
hermes doctor
hermes setup
hermes auth
hermes model
hermes tools
hermes status
This order prevents an entire class of confusion: wrong model, provider without credentials, overly broad toolset, gateway accidentally enabled, or a session resumed in the wrong profile.
After that, check skills and memory:
hermes skills list
hermes memory status
hermes sessions list
Here Hermes begins to show its difference: not only “which model is active?”, but “which operational identity is ready to work?”.
Practical Flow: Working in the TUI Link to heading
After basic configuration, open the TUI:
hermes --tui
Inside it, the minimum kit is:
/help
/status
/model
/tools
/toolsets
/skills
This block answers the operational questions: where am I, which model is active, which tools are available, and which skills can I load.
When execution is in progress, the steering commands enter:
/queue
/steer
/busy status
/busy queue
/busy steer
/busy interrupt
The mental trio is simple:
/queuestores the next instruction;/steercorrects the direction of the current work;/busydefines how Hermes treats new input while busy.
For larger sessions:
/background
/goal
/compress
/rollback
That is the main point of this article: the TUI is not just a pretty screen. It is the place where you pilot the agent while it executes.
Hermes Command Checklist Link to heading
For initial configuration:
hermes doctor
hermes setup
hermes auth
hermes model
hermes tools
hermes status
To open and resume sessions:
hermes
hermes --tui
hermes --continue
hermes --resume <session_id>
To operate inside the TUI:
/help
/status
/model
/tools
/toolsets
/skills
/queue
/steer
/busy status
For maintenance:
hermes sessions list
hermes memory status
hermes curator
hermes logs
For integrations:
hermes gateway setup
hermes mcp list
hermes acp
Conclusion Link to heading
The Hermes CLI is less “question and answer” and more agent cockpit. Configuration commands prepare provider, model, credentials, memory, and tools. The TUI concentrates fine control: /queue, /steer, /busy, /background, /goal, /compress, and /rollback.
Skills complete this idea. They turn learning into procedure. Curator tries to prevent that procedure from becoming a mess. Toolsets limit what the agent can touch. Sessions and memory create continuity.
The weak use of Hermes is treating it as a little question box in the terminal. The strong use is configuring a persistent agent, controlling its tools, and conducting execution through the TUI. That is where queue, steer, skills, Curator, memory, and sessions stop being feature names and become workflow.
In the next post, we will cover the part that decides whether this is brilliant or dangerous: gateway, security, Docker, containers, and ACP.