Hermes Agent Cheat Sheet: CLI Commands, Slash Commands (PDF)

Hermes Agent ships more than 60 top-level commands and over 100 slash commands, and most of them never come up on day one. This Hermes Agent cheat sheet keeps the ones you’ll actually type: installing and updating, pointing the agent at a model, one-shot runs for scripts, sessions, config, toolsets, MCP servers, cron jobs and the slash commands inside the interactive CLI. Each table row was checked against the release’s own --help output and the command registry in its source.

Original content from computingforgeeks.com - post 182823

Other Hermes Agent command lists stop at the help text. This one also shows what happens when you run the agent on a small local model through Ollama: a model that thinks for 11 minutes and then sends a broken tool call, the 4,096-token context Ollama hands out by default, and the OOM kill that follows when you raise it carelessly. Built and run on an Ubuntu 24.04 VM with 8 vCPUs, 16 GB of RAM and no GPU in November 2026, using Hermes Agent v0.22.5 against Ollama with qwen3:4b-instruct.

Hermes Agent cheat sheet: commands at a glance

Each table covers one job, so you can scan for the task instead of the flag. Two kinds of flags are mixed in, and putting them in the wrong place is the most common reason a command errors out:

1. Global flags such as -z, -m, -t, -c and -p go right after hermes, before any subcommand.
2. Scripting flags such as -q, -Q and --format belong to hermes chat and go after it.

Every row below was checked against the --help output on the lab VM, because Hermes adds and renames commands between patch releases and a stale flag simply fails.

Install, update and health checks

Command	What it does
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash	Install the latest stable release into ~/.hermes, then run the setup wizard
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash -s -- --non-interactive	Install without the wizard (alias --skip-setup)
hermes --version	Version, commit, install method, Python and OpenAI SDK
hermes update --check	Check for a new release without installing it
hermes update	Pull the latest release and reinstall dependencies
hermes doctor	Check config, dependencies, auth and the data directories
hermes status	Model, provider, gateway, platforms and cron jobs
hermes setup	Rerun the setup wizard
hermes uninstall --dry-run	Show what an uninstall would remove

Start, resume and isolate sessions

Command	What it does
hermes	Start the interactive CLI
hermes --tui	Start the newer full-screen TUI instead
hermes -c	Resume the most recent session
hermes -c "my project"	Resume a session by its title
hermes --resume latest	Same as -c; also takes a session ID
hermes -w	Run in an isolated git worktree
hermes --checkpoints	Snapshot files before destructive edits; undo with /rollback
hermes --yolo	Skip every dangerous-command approval prompt
hermes --safe-mode	Start without user config, rules, plugins and MCP servers
hermes --ignore-user-config	Ignore config.yaml; .env keys still load

One-shot runs and scripting

Command	What it does
hermes -z "prompt"	Print only the final answer; approvals auto-bypassed
hermes -z "prompt" --usage-file usage.json	Also write token counts and cost to JSON
hermes chat -q "prompt" --oneshot	Answer one query with tool previews and a session footer, then exit
hermes chat -q "prompt" -Q	Quiet: final response and session info only
hermes chat -q "prompt" --format stream-json	Emit newline-delimited JSON events
hermes chat --query-file prompt.md --oneshot	Read the query from a file; - reads stdin
hermes chat -c -q "follow-up" --oneshot	Send one more turn to the last session
hermes chat -q "prompt" --max-turns 20	Cap tool-calling iterations (default 500)
hermes chat -q "prompt" --run-budget 300	Wall-clock budget in seconds for the run

Models and providers

Command	What it does
hermes model	Pick the default provider and model interactively
hermes -m MODEL -z "prompt"	Override the model for one run
hermes chat --provider custom --base-url URL -m MODEL	Use any OpenAI-compatible endpoint for one launch
hermes chat --api-key KEY	API key for this launch only, never saved
hermes --reasoning low	Reasoning effort for this run (none to ultra)
hermes fallback add	Add a provider to try when the primary fails
hermes auth list	List pooled provider credentials
hermes insights --days 7	Tokens, cost, models and top tools for a period

Config files and keys

Command	What it does
hermes config	Show the current configuration
hermes config edit	Open config.yaml in $EDITOR
hermes config get model	Print a resolved value or block
hermes config set model.default MODEL	Set a key in ~/.hermes/config.yaml
hermes config unset KEY	Remove a key
hermes config path	Print the config.yaml path
hermes config env-path	Print the .env path where API keys live
hermes config check	Show missing or outdated settings and optional keys

Tools, skills, MCP and plugins

Command	What it does
hermes tools list	Every toolset with its enabled state
hermes tools disable browser	Turn a toolset off (enable turns it back on)
hermes -t terminal,file	Load only these toolsets for this run
hermes prompt-size	Byte breakdown of system prompt and tool schemas
hermes skills list	Installed skills
hermes skills search QUERY	Search skill registries
hermes skills install IDENTIFIER	Install a skill by ID or SKILL.md URL
hermes -s SKILL	Preload a skill for the session
hermes mcp add NAME --command npx --args PKG	Add a stdio MCP server (--args goes last)
hermes mcp add NAME --url URL	Add an HTTP MCP server
hermes mcp list	Configured MCP servers
hermes mcp test NAME	Connect and count a server’s tools
hermes plugins list	Installed plugins and their state

Sessions, logs and backups

Command	What it does
hermes sessions list	Recent sessions with title, workspace and ID
hermes sessions browse	Interactive picker to search and resume
hermes sessions rename ID TITLE	Give a session a title you can resume by
hermes sessions export --format md	Export sessions to Markdown (or jsonl, html)
hermes sessions stats	Session count, messages and database size
hermes logs -f	Follow agent.log
hermes logs errors	Show errors.log
hermes backup	Zip config, skills, sessions and data

Cron, gateway and profiles

Command	What it does
hermes cron create "every 2h" "prompt" --name NAME	Schedule a recurring agent task
hermes cron list	Scheduled jobs with next run time
hermes cron remove NAME	Delete a job
hermes gateway setup	Connect Telegram, Discord, Slack and others
hermes gateway run	Run the messaging gateway in the foreground
hermes gateway install	Install the gateway as a user service
hermes gateway stop	Stop this profile’s gateway
hermes profile create NAME	New isolated Hermes home with its own wrapper
hermes -p NAME chat	Run any command against a named profile
hermes dashboard	Start the web dashboard on port 9119

Slash commands for sessions and context

Command	What it does
/new	Fresh session ID and history (alias /reset)
/retry	Resend the last message
/undo 2	Back up N user turns and re-prompt
/title NAME	Name the session for hermes -c "NAME"
/branch	Fork the session into a new thread (alias /fork)
/compress	Summarize old turns to free context (alias /compact)
/context	Context gauge with category breakdown (alias /ctx)
/status	Session, model, token and context info
/usage	Token usage and rate limits
/rollback	List or restore filesystem checkpoints
/save md	Export the conversation as json, md or html
/quit	Exit (--delete also removes the history)

Slash commands for work, config and tools

Command	What it does
/model	Switch model for this session (--global saves it)
/reasoning high	Change reasoning effort, or show and hide it
/yolo	Toggle approval bypass
/approvals smart	Persistent approval mode: manual, smart or off
/plan TASK	Write a plan to .hermes/plans/ without running it
/goal TEXT	Standing goal the agent works on across turns
/steer TEXT	Inject a message after the next tool call
/queue TEXT	Queue a prompt for the next turn
/bg TEXT	Run a prompt in a background session
/btw QUESTION	Side question without interrupting the work
/tools disable NAME	Turn tools off in the running session
/skills	Search, install and inspect skills
/init	Generate or update AGENTS.md from a repo scan
/learn WHAT	Turn a directory, URL or this chat into a skill
/reload-mcp	Reload MCP servers from config
/help skills	List skill commands; /help TEXT filters

Keys in the interactive CLI

Key	What it does
Ctrl+P	Fuzzy command palette (same as /palette)
Ctrl+J	New line; Alt+Enter and \ then Enter also work
Ctrl+G	Draft the prompt in an editor (Alt+G in VS Code and Cursor)
Alt+V	Paste a clipboard image (same as /paste)
Ctrl+C	Interrupt the current turn

Install Hermes Agent on Linux

The installer needs git and curl, plus libatomic1 for its bundled Node.js. On the lab VM it installed that package itself with sudo -n apt-get, which only works with passwordless sudo, so on a minimal server run sudo apt install -y libatomic1 first. It clones the latest stable tag into ~/.hermes/hermes-agent, downloads its own uv, Python, Node.js, ripgrep and FFmpeg into ~/.hermes/tools, and builds a hash-verified virtualenv, so nothing touches the system Python. The two skip flags below leave out the Playwright browser and computer-use pieces, which a headless server doesn’t need, and --non-interactive stops it from opening the setup wizard at the end:

curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash -s -- --non-interactive --skip-browser --skip-computer-use

It took about six minutes on the lab VM, most of it the FFmpeg download and the dependency install. The first lines tell you which release you’re getting, and that --channel main would track every commit instead:

✓ prerequisites ok (git, curl)
→ Installing the latest stable release (v0.22.5); --channel main follows every commit
→ Cloning https://github.com/NousResearch/hermes-agent.git (main) into /home/joshua/.hermes/hermes-agent
Cloning into '/home/joshua/.hermes/.hermes-clone-VOqPwr/tree'...
→ Fetching v0.22.5
→ Checking out v0.22.5 (attempt 1 of 2)
HEAD is now at bf0203a794 fix(launchers): a Python repin republishes hermes.exe, not a .cmd
✓ Hermes Agent cloned

The hermes launcher lands in ~/.local/bin, and the installer adds that directory to your PATH in ~/.bashrc. Reload the shell so the current session picks it up:

source ~/.bashrc

Then confirm the version and that no newer release is waiting. hermes update --check only reads, so it’s safe to run anywhere.

hermes --version
hermes update --check

Both commands agree on the stable tag and the commit it was built from, which matters when you file a bug, because maintainers ask for the commit first.

Run hermes doctor next. On a fresh install it should report the config version as up to date and list only optional warnings, such as Nous Portal or Codex auth not logged in, plus the Telegram and Discord libraries you don’t need until you set up the gateway.

Point Hermes Agent at a local Ollama model

Hermes talks to any OpenAI-compatible endpoint, so a local model is three config keys away. If you don’t have Ollama yet, the Ollama commands cheat sheet covers the install and the server variables used below. Pull a non-thinking instruct model first, because the plain qwen3:4b tag broke tool calls in this lab (the error is at the end of this page):

ollama pull qwen3:4b-instruct

Now raise Ollama’s context window. Hermes refuses models below 64,000 tokens of context (MINIMUM_CONTEXT_LENGTH = 64_000 in agent/model_metadata.py), but on a CPU-only machine like this one Ollama serves 4,096 unless you tell it otherwise, and in this lab Hermes did not stop on that. It ran anyway against the 4K window, and the thinking model produced no answer in 13 minutes. Create a systemd drop-in for the Ollama service:

sudo mkdir -p /etc/systemd/system/ollama.service.d
sudo vim /etc/systemd/system/ollama.service.d/override.conf

Add these four lines. The first sets the 64K window, and the other three are what stopped the OOM killer on a 16 GB box, by quantizing the KV cache and refusing to keep two models in memory at once. Skip them on a big GPU if you like, but on a small machine the context bump alone is what crashes Ollama.

[Service]
Environment="OLLAMA_CONTEXT_LENGTH=65536"
Environment="OLLAMA_FLASH_ATTENTION=1"
Environment="OLLAMA_KV_CACHE_TYPE=q8_0"
Environment="OLLAMA_MAX_LOADED_MODELS=1"

Reload systemd and restart Ollama so the new environment applies.

sudo systemctl daemon-reload
sudo systemctl restart ollama

Point Hermes at the local endpoint. custom is the provider name for any OpenAI-compatible server, and the base URL needs the /v1 suffix:

hermes config set model.provider custom
hermes config set model.base_url http://localhost:11434/v1
hermes config set model.default qwen3:4b-instruct
hermes config get model

After the first request, ollama ps should show the 65536 context. The model takes 8.2 GB with the q8_0 cache, against roughly 12 GB for the thinking variant with the default cache, so a second model loading next to it is enough to run a 16 GB VM out of memory:

A 4B model on CPU is a test rig, not a daily driver. It proves the wiring and the commands, but anything longer than a few tool calls is slow, so pick a bigger model on a GPU for real work. The Ollama models cheat sheet lists which models fit which VRAM tier.

Run one-shot queries and resume sessions

Hermes has two one-shot modes, and they behave differently. hermes chat -q prints the query, a tool preview, the answer and a footer with the session ID. hermes -z prints only the final text, which is what you want in a pipe. Watch the TTY rule from the help text: in a real terminal, hermes chat -q seeds an interactive session instead of exiting, so add --oneshot or -Q when you want it to answer and quit. The two examples below carry --oneshot for that reason. They ran over a non-interactive SSH session, where it is implied anyway, so the output is the same either way. They also carry --yolo because a run with no TTY can’t answer an approval prompt. Keep that to throwaway machines, and use --checkpoints anywhere your files matter:

hermes chat -q "What is the hostname of this machine and how much free disk space is on /? Use the terminal." -t terminal --yolo --oneshot

Hermes ran hostname and df through the terminal tool and answered in 3 minutes 42 seconds. Most of that was Ollama loading the model cold and chewing through the prompt on CPU, so don’t judge the agent’s speed by a first run.

Use the footer to get back into that session, either by ID or by the title the agent generated. -c with no name picks the most recent one, and a follow-up on a warm model took 16 seconds:

hermes chat -c -q "Now show me the kernel version with uname -r." -t terminal --yolo --oneshot

Look for the resumed line, which confirms it loaded the earlier messages before running the new command.

Query: Now show me the kernel version with uname -r.
↻ Resumed session
local-eae0cb93bf38639a2dfa149e9e7f56447ec82d4277cf9c677cfa78a20a7457b2 "Get
machine hostname and free disk space" (1 user message, 4 total messages)
💻 $ uname -r

────────────────────────────────────────
☤ Hermes
Kernel version: 6.8.0-106-generic
────────────────────────────────────────

For scripts and CI, -z plus --usage-file gives you a clean answer on stdout and a JSON report on disk. The help text says the report is written even when the run fails, so a pipeline can always account for tokens:

hermes -z "Reply with the output of uname -m only." -t terminal --usage-file /tmp/usage.json

Stdout held just x86_64. The report shows two API calls and an extra one for title generation, and a cost of 0 marked unknown because Hermes has no price list for a local model:

{
  "estimated_cost_usd": 0.0,
  "cost_status": "unknown",
  "cost_source": "none",
  "input_tokens": 7382,
  "output_tokens": 28,
  "cache_read_tokens": 3683,
  "cache_write_tokens": 0,
  "reasoning_tokens": 0,
  "total_tokens": 7410,
  "api_calls": 2,
  "model": "qwen3:4b-instruct",
  "provider": "custom",
  "session_id": "local-3f8ba96345b66cfeb3bfd5369eea4678e4a9a7afb98622a7919ebacbe5aee18e",
  "completed": true,
  "partial": false,
  "interrupted": false,
  "turn_exit_reason": "text_response(finish_reason=stop)",
  "failed": false,
  "service_tier": null,
  "auxiliary": {
    "api_calls": 1,
    "input_tokens": 240,
    "output_tokens": 10,
    "cache_read_tokens": 4,
    "cache_write_tokens": 0,
    "reasoning_tokens": 0,
    "estimated_cost_usd": 0,
    "total_tokens": 250,
    "by_task": {
      "title_generation": {
        "api_calls": 1,
        "cache_read_tokens": 4,
        "cache_write_tokens": 0,
        "estimated_cost_usd": 0,
        "input_tokens": 240,
        "output_tokens": 10,
        "reasoning_tokens": 0
      }
    }
  },
  "total_including_auxiliary": {
    "estimated_cost_usd": 0.0,
    "total_tokens": 7660,
    "api_calls": 3
  }
}

One thing to know before you put -z in a cron job or CI step: approvals are auto-bypassed in that mode, so any dangerous command the model decides to run goes through without asking. Pair it with a narrow -t list and, for anything that touches a real repo, --checkpoints or -w.

Shrink the prompt with toolsets

Every enabled toolset adds its JSON schema to every request, and on a small or metered model that is the biggest cost you control. hermes prompt-size shows the bill:

hermes prompt-size

With the default toolsets the system prompt is 17.5 KB and the tool schemas add another 39.2 KB across 20 tools, 58,117 bytes before you type anything.

At the usual rough rate of four bytes a token, that is around 15,000 tokens, and this CPU VM processed prompts at about 57 tokens a second, so the full set costs minutes per cold turn. With -t terminal the whole two-call run above came to 7,382 input tokens. The toolsets you’ll mix most often:

1. Run hermes tools list to see the names. Defaults include web, browser, terminal, file, code_execution, memory, skills and delegation; kanban, stt and video start disabled.
2. Limit a single run with -t terminal,file for shell and file work.
3. Disable a toolset for good with hermes tools disable browser, or inside a session with /tools disable.
4. Rerun hermes prompt-size to check the saving.

The delegation toolset alone is 4.5 KB of schema, and it’s the piece that spawns subagents. If you want to understand what a planner, memory and tool loop like this is doing between your prompt and the shell, Build an AI Agent (From Scratch) (paid link) by Jungjun Hur and Younghee Song (Manning, 2026) builds one step by step in Python. It makes the trade-off behind each toolset easier to judge.

Know which Hermes config setting wins

Hermes keeps settings in ~/.hermes/config.yaml and secrets in ~/.hermes/.env, and hermes config path and hermes config env-path print both. The precedence isn’t the same for every setting, and getting it wrong means a run quietly using a provider you didn’t expect. This is how the source resolves the two settings people override most:

Setting	Order, first match wins	Source
Provider	--provider flag, then model.provider in config.yaml, then HERMES_INFERENCE_PROVIDER, else auto	hermes_cli/runtime_provider.py, resolve_requested_provider
Model (one-shot)	-m flag, then HERMES_INFERENCE_MODEL, then model.default in config.yaml	hermes_cli/oneshot.py, _resolve_model_and_provider
API keys	~/.hermes/.env loads with override on, so it beats a key exported in your shell	hermes_cli/env_loader.py

The provider row is the trap. An exported HERMES_INFERENCE_PROVIDER loses to whatever is saved in config.yaml, which the source explains as “Config beats the env so chat uses the endpoint the user last saved, not a stale shell/.env override”. The model row runs the other way: HERMES_INFERENCE_MODEL beats the config default. When you pass a model explicitly, Hermes also auto-detects a provider for it, while a model taken from config keeps the configured provider. If a run picks the wrong backend, hermes config get model and hermes --safe-mode are the two quickest ways to see whether your setup or Hermes itself is the cause.

Add an MCP server to Hermes

hermes mcp add connects to the server, lists its tools and asks whether to enable them. If nothing answers that question, it prints “Cancelled.” and saves nothing, which is easy to miss in a script, so pipe a Y into it. You don’t need Node on your PATH, because Hermes runs a bare npx with the Node it bundles under ~/.hermes/tools. On the lab VM command -v npx found nothing and the server still connected. The filesystem server here is limited to one sandbox directory:

mkdir -p ~/mcp-sandbox
echo Y | hermes mcp add filesystem --command npx --args -y @modelcontextprotocol/server-filesystem ~/mcp-sandbox
hermes mcp list

Hermes found 14 tools, saved the server to config.yaml and listed it as enabled. Open sessions only see it after /reload-mcp, so run that rather than restarting a long session.

Keep --args as the last option, because everything after it is passed to the server command. hermes mcp test filesystem reconnects and recounts the tools whenever you suspect a server is down. Running Hermes itself as an MCP server for other clients now lives in the mcp-serve plugin rather than core, per the release notes.

Use Hermes slash commands in the CLI

Type hermes with no arguments and the start screen lists the loaded toolsets, MCP servers and skills. This is the classic CLI that hermes opens by default:

Don’t read the model line as proof of which provider is serving you. It says “qwen3:4b-instruct · Nous Research” even on a custom Ollama endpoint, while /status and hermes status show the real provider. /help groups the commands by job, and /help TEXT filters the list.

The registry in hermes_cli/commands.py holds just over 100 commands, and some only work on one side. /clear, /history, /skin and /plugins are CLI-only, while /approve, /deny, /sethome and /restart only exist in the messaging gateway. /usage before the first turn just says there’s no active agent yet, so send a message first. If you already know the slash commands in the Claude Code cheat sheet or the Codex CLI cheat sheet, /compress, /model and /init will feel familiar; /goal, /steer, /learn and /bg are where Hermes goes its own way.

Schedule jobs and split work into profiles

Cron jobs are agent prompts on a schedule, not shell commands. The schedule takes 30m, every 2h or a cron expression such as 0 9 * * *, and --deliver can send the result to Telegram, Discord or Signal once the gateway is set up. A job created and removed in the lab:

hermes cron create "every 2h" "Report free disk space on /" --name disk-check
hermes cron list
hermes cron remove disk-check

With no --deliver the job delivers locally, and the list shows the next run two hours out.

Profiles give you separate Hermes homes with their own config, keys, skills and sessions. hermes profile create demo made ~/.hermes/profiles/demo, synced 58 bundled skills and created a demo wrapper in ~/.local/bin, so demo chat and hermes -p demo chat do the same thing. A new profile with no keys of its own inherits keys from your shell environment, which the command warns about; run demo setup before you trust it with a different provider.

One background process is easy to miss: any hermes chat or hermes -z run starts a gateway in the background (gateway run --quiet --idle-exit), even with no messaging platform configured. hermes status then reports “Gateway: ✓ running”. It exits when idle, and hermes gateway stop ends it at once.

Fix common Hermes Agent errors

Every error below came out of the lab run, all of them saved to the lab log, except the context-floor message, which is quoted from the source because Hermes never raised it here.

Error: “tool_call requires ‘calls’ (an array of {name, arguments})”

A thinking model failing at Hermes’ tool format produces this error. The plain qwen3:4b tag reasoned for 661 seconds about which commands to run, then emitted a call the executor couldn’t parse, twice. --reasoning none didn’t stop the thinking on the custom endpoint, so the flag is no workaround here.

Switch to an instruct build (ollama pull qwen3:4b-instruct, then hermes config set model.default qwen3:4b-instruct). The same prompt then made two clean terminal calls.

Error: “Model … has a context window of … tokens, which is below the minimum 64,000”

Hermes raises this in _enforce_minimum_context (agent/agent_init.py) when the model reports a window under 64,000 tokens, although against Ollama’s 4,096 default in this lab it never fired. The message tells you to start the server with at least 64K (llama.cpp -c 64000, vLLM --max-model-len, Ollama OLLAMA_CONTEXT_LENGTH or a Modelfile num_ctx), or to set model.ollama_num_ctx in config.yaml to the window the server really serves, which must itself be at least 64K. The Ollama override above is the fix, and ollama ps confirms it.

Error: “ollama.service: Failed with result ‘oom-kill'”

With the 64K window and none of the cache settings, the kernel killed Ollama three times in three minutes on this 16 GB VM while the lab switched between the two 4B models. Hermes only sees the symptom, httpx.ConnectError: [Errno 111] Connection refused, and keeps retrying, so the log you need is the Ollama one. Fix it in this order:

1. Confirm the kill with journalctl -u ollama | grep oom.
2. Add OLLAMA_KV_CACHE_TYPE=q8_0, OLLAMA_FLASH_ATTENTION=1 and OLLAMA_MAX_LOADED_MODELS=1 to the override file.
3. Run sudo systemctl daemon-reload and sudo systemctl restart ollama.
4. Send one prompt and check the SIZE column of ollama ps against your free RAM.

With those settings the instruct model held at 8.2 GB and Ollama was not killed again for the rest of the lab.

“Enable all 14 tools? [Y/n/select]:” then “Cancelled.”

hermes mcp add ran with no input attached, got no answer and dropped the server. Pipe echo Y into it, as in the MCP section, or run it in an interactive shell.

Hermes is one of several terminal agents worth knowing. If you’re choosing between them, the OpenCode CLI cheat sheet and the Gemini CLI cheat sheet cover the same ground for their tools, and the OpenCode vs Claude Code vs Cursor comparison puts the coding agents side by side. The Hermes Agent releases page ships patch releases every few days, so run hermes update --check before you trust any flag that isn’t on this page.